vega_lite_5/

schema.rs

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#![allow(
    missing_docs,
    clippy::doc_lazy_continuation,
    clippy::large_enum_variant
)]

use crate::removable_value::RemovableValue;
use derive_builder::Builder;
use derive_more::From;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// A Vega-Lite top-level specification. This is the root class for all Vega-Lite
/// specifications. (The json schema is generated from this type.)
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Vegalite {
    /// URL to [JSON schema](http://json-schema.org/) for a Vega-Lite specification. Unless you
    /// have a reason to change this, use `https://vega.github.io/schema/vega-lite/v5.json`.
    /// Setting the `$schema` property allows automatic validation and autocomplete in editors
    /// that support JSON schema.
    #[serde(rename = "$schema")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default = "Some(\"https://vega.github.io/schema/vega-lite/v5.json\".to_string())")]
    pub schema: Option<String>,
    /// The alignment to apply to grid rows and columns. The supported string values are `"all"`,
    /// `"each"`, and `"none"`.
    ///
    /// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
    /// one after the other.
    /// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
    /// column may be of variable size.
    /// - For `"all"`, subviews will be aligned and each row or column will be sized identically
    /// based on the maximum observed size. String values for this property will be applied to
    /// both grid rows and columns.
    ///
    /// Alternatively, an object value of the form `{"row": string, "column": string}` can be
    /// used to supply different alignments for rows and columns.
    ///
    /// __Default value:__ `"all"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Box<VegaliteAlign>>,
    /// How the visualization size should be determined. If a string, should be one of `"pad"`,
    /// `"fit"` or `"none"`. Object values can additionally specify parameters for content sizing
    /// and automatic resizing.
    ///
    /// __Default value__: `pad`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub autosize: Option<Box<Autosize>>,
    /// CSS color property to use as the background of the entire view.
    ///
    /// __Default value:__ `"white"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub background: Option<Box<Color>>,
    /// The bounds calculation method to use for determining the extent of a sub-plot. One of
    /// `full` (the default) or `flush`.
    ///
    /// - If set to `full`, the entire calculated bounds (including axes, title, and legend) will
    /// be used.
    /// - If set to `flush`, only the specified width and height values for the sub-view will be
    /// used. The `flush` setting can be useful when attempting to place sub-plots without axes
    /// or legends into a uniform grid structure.
    ///
    /// __Default value:__ `"full"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bounds: Option<Box<Bounds>>,
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// An object value of the form `{"row": boolean, "column": boolean}` can be used to supply
    /// different centering values for rows and columns.
    ///
    /// __Default value:__ `false`
    ///
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<Box<Center>>,
    /// Vega-Lite configuration object. This property can only be defined at the top-level of a
    /// specification.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub config: Option<Box<ConfigClass>>,
    /// An object describing the data source. Set to `null` to ignore the parent's data source.
    /// If no data is set, it is derived from the parent.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub data: RemovableValue<UrlData>,
    /// A global data store for named datasets. This is a mapping from names to inline datasets.
    /// This can be an array of objects or primitive values or a string. Arrays of primitive
    /// values are ingested as objects with a `data` property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datasets: Option<HashMap<String, InlineDatasetValue>>,
    /// Description of this mark for commenting purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<String>,
    /// A key-value mapping between encoding channels and definition of fields.
    ///
    /// A shared key-value mapping between encoding channels and definition of fields in the
    /// underlying layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<Box<EdEncoding>>,
    /// The height of a visualization.
    ///
    /// - For a plot with a continuous y-field, height should be a number.
    /// - For a plot with either a discrete y-field or no y-field, height can be either a number
    /// indicating a fixed height or an object in the form of `{step: number}` defining the
    /// height per discrete step. (No y-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on height, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousHeight` for a plot with a continuous
    /// y-field and `config.view.discreteHeight` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// height of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`height`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<SpecHeight>,
    /// A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
    /// `"line"`, `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark
    /// definition object](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<AnyMark>,
    /// Name of the visualization for later reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// The default visualization padding, in pixels, from the edge of the visualization canvas
    /// to the data rectangle. If a number, specifies padding for all sides. If an object, the
    /// value should have the format `{"left": 5, "top": 5, "right": 5, "bottom": 5}` to specify
    /// padding for each side of the visualization.
    ///
    /// __Default value__: `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding: Option<Box<Padding>>,
    /// An array of parameters that may either be simple variables, or more complex selections
    /// that map user input to data queries.
    ///
    /// Dynamic variables or selections that parameterize a visualization.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<Vec<TopLevelParameter>>,
    /// An object defining properties of geographic projection, which will be applied to `shape`
    /// path for `"geoshape"` marks and to `latitude` and `"longitude"` channels for other
    /// marks.
    ///
    /// An object defining properties of the geographic projection shared by underlying layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection: Option<Box<Projection>>,
    /// Scale, axis, and legend resolutions for view composition specifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<Box<Resolve>>,
    /// The spacing in pixels between sub-views of the composition operator. An object of the
    /// form `{"row": number, "column": number}` can be used to set different spacing values for
    /// rows and columns.
    ///
    /// __Default value__: Depends on `"spacing"` property of [the view composition
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#view-config) (`20` by
    /// default)
    ///
    /// The spacing in pixels between sub-views of the concat operator.
    ///
    /// __Default value__: `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<Box<Spacing>>,
    /// Title for the plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title: Option<TitleUnion>,
    /// An array of data transformations such as filter and new field calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform: Option<Vec<Transform>>,
    /// Optional metadata that will be passed to Vega. This object is completely ignored by Vega
    /// and Vega-Lite and can be used for custom metadata.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub usermeta: Option<HashMap<String, Option<serde_json::Value>>>,
    /// An object defining the view background's fill and stroke.
    ///
    /// __Default value:__ none (transparent)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub view: Option<Box<ViewBackground>>,
    /// The width of a visualization.
    ///
    /// - For a plot with a continuous x-field, width should be a number.
    /// - For a plot with either a discrete x-field or no x-field, width can be either a number
    /// indicating a fixed width or an object in the form of `{step: number}` defining the width
    /// per discrete step. (No x-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on width, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousWidth` for a plot with a continuous
    /// x-field and `config.view.discreteWidth` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// width of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`width`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<SpecHeight>,
    /// The number of columns to include in the view composition layout.
    ///
    /// __Default value__: `undefined` -- An infinite number of columns (a single row) will be
    /// assumed. This is equivalent to `hconcat` (for `concat`) and to using the `column` channel
    /// (for `facet` and `repeat`).
    ///
    /// __Note__:
    ///
    /// 1) This property is only for:
    /// - the general (wrappable) `concat` operator (not `hconcat`/`vconcat`)
    /// - the `facet` and `repeat` operator with one field/repetition definition (without
    /// row/column nesting)
    ///
    /// 2) Setting the `columns` to `1` is equivalent to `vconcat` (for `concat`) and to using
    /// the `row` channel (for `facet` and `repeat`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<f64>,
    /// Definition for how to facet the data. One of: 1) [a field definition for faceting the
    /// plot by one field](https://vega.github.io/vega-lite/docs/facet.html#field-def) 2) [An
    /// object that maps `row` and `column` channels to their field
    /// definitions](https://vega.github.io/vega-lite/docs/facet.html#mapping)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<Box<Facet>>,
    /// A specification of the view that gets faceted.
    ///
    /// A specification of the view that gets repeated.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spec: Option<Box<VegaliteSpec>>,
    /// Layer or single view specifications to be layered.
    ///
    /// __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
    /// layering facet specifications is not allowed. Instead, use the [facet
    /// operator](https://vega.github.io/vega-lite/docs/facet.html) and place a layer inside a
    /// facet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layer: Option<Vec<LayerSpec>>,
    /// Definition for fields to be repeated. One of: 1) An array of fields to be repeated. If
    /// `"repeat"` is an array, the field can be referred to as `{"repeat": "repeat"}`. The
    /// repeated views are laid out in a wrapped row. You can set the number of columns to
    /// control the wrapping. 2) An object that maps `"row"` and/or `"column"` to the listed
    /// fields to be repeated along the particular orientations. The objects `{"repeat": "row"}`
    /// and `{"repeat": "column"}` can be used to refer to the repeated field respectively.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub repeat: Option<Box<RepeatUnion>>,
    /// A list of views to be concatenated.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub concat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a column.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub vconcat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a row.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hconcat: Option<Vec<Spec>>,
}

/// The alignment to apply to grid rows and columns. The supported string values are `"all"`,
/// `"each"`, and `"none"`.
///
/// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
/// one after the other.
/// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
/// column may be of variable size.
/// - For `"all"`, subviews will be aligned and each row or column will be sized identically
/// based on the maximum observed size. String values for this property will be applied to
/// both grid rows and columns.
///
/// Alternatively, an object value of the form `{"row": string, "column": string}` can be
/// used to supply different alignments for rows and columns.
///
/// __Default value:__ `"all"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum VegaliteAlign {
    Enum(LayoutAlign),
    RowColLayoutAlign(RowColLayoutAlign),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RowColLayoutAlign {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<LayoutAlign>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<LayoutAlign>,
}

/// The alignment to apply to symbol legends rows and columns. The supported string values
/// are `"all"`, `"each"` (the default), and `none`. For more information, see the [grid
/// layout documentation](https://vega.github.io/vega/docs/layout).
///
/// __Default value:__ `"each"`.
///
/// The alignment to apply to row/column facet's subplot. The supported string values are
/// `"all"`, `"each"`, and `"none"`.
///
/// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
/// one after the other.
/// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
/// column may be of variable size.
/// - For `"all"`, subviews will be aligned and each row or column will be sized identically
/// based on the maximum observed size. String values for this property will be applied to
/// both grid rows and columns.
///
/// __Default value:__ `"all"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LayoutAlign {
    All,
    Each,
    None,
}

/// How the visualization size should be determined. If a string, should be one of `"pad"`,
/// `"fit"` or `"none"`. Object values can additionally specify parameters for content sizing
/// and automatic resizing.
///
/// __Default value__: `pad`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Autosize {
    AutoSizeParams(AutoSizeParams),
    Enum(AutosizeType),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AutoSizeParams {
    /// Determines how size calculation should be performed, one of `"content"` or `"padding"`.
    /// The default setting (`"content"`) interprets the width and height settings as the data
    /// rectangle (plotting) dimensions, to which padding is then added. In contrast, the
    /// `"padding"` setting includes the padding within the view size calculations, such that the
    /// width and height settings indicate the **total** intended size of the view.
    ///
    /// __Default value__: `"content"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub contains: Option<Contains>,
    /// A boolean flag indicating if autosize layout should be re-calculated on every view
    /// update.
    ///
    /// __Default value__: `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resize: Option<bool>,
    /// The sizing format type. One of `"pad"`, `"fit"`, `"fit-x"`, `"fit-y"`,  or `"none"`. See
    /// the [autosize type](https://vega.github.io/vega-lite/docs/size.html#autosize)
    /// documentation for descriptions of each.
    ///
    /// __Default value__: `"pad"`
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub auto_size_params_type: Option<AutosizeType>,
}

/// The sizing format type. One of `"pad"`, `"fit"`, `"fit-x"`, `"fit-y"`,  or `"none"`. See
/// the [autosize type](https://vega.github.io/vega-lite/docs/size.html#autosize)
/// documentation for descriptions of each.
///
/// __Default value__: `"pad"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum AutosizeType {
    Fit,
    #[serde(rename = "fit-x")]
    FitX,
    #[serde(rename = "fit-y")]
    FitY,
    None,
    Pad,
}

/// Determines how size calculation should be performed, one of `"content"` or `"padding"`.
/// The default setting (`"content"`) interprets the width and height settings as the data
/// rectangle (plotting) dimensions, to which padding is then added. In contrast, the
/// `"padding"` setting includes the padding within the view size calculations, such that the
/// width and height settings indicate the **total** intended size of the view.
///
/// __Default value__: `"content"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Contains {
    Content,
    Padding,
}

/// CSS color property to use as the background of the entire view.
///
/// __Default value:__ `"white"`
///
/// The color of the header label, can be in hex color code or regular color name.
///
/// Color of the header title, can be in hex color code or regular color name.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Color {
    BackgroundExprRef(BackgroundExprRef),
    String(String),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BackgroundExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// The bounds calculation method to use for determining the extent of a sub-plot. One of
/// `full` (the default) or `flush`.
///
/// - If set to `full`, the entire calculated bounds (including axes, title, and legend) will
/// be used.
/// - If set to `flush`, only the specified width and height values for the sub-view will be
/// used. The `flush` setting can be useful when attempting to place sub-plots without axes
/// or legends into a uniform grid structure.
///
/// __Default value:__ `"full"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Bounds {
    Flush,
    Full,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Center {
    Bool(bool),
    RowColBoolean(RowColBoolean),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RowColBoolean {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<bool>,
}

/// A specification of the view that gets repeated.
///
/// Any specification in Vega-Lite.
///
/// Unit spec that can have a composite mark and row or column channels (shorthand for a
/// facet spec).
///
/// A full layered plot specification, which may contains `encoding` and `projection`
/// properties that will be applied to underlying unit (single-view) specifications.
///
/// Base interface for a repeat specification.
///
/// Base interface for a facet specification.
///
/// Base interface for a generalized concatenation specification.
///
/// Base interface for a vertical concatenation specification.
///
/// Base interface for a horizontal concatenation specification.
///
/// A specification of the view that gets faceted.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SpecSpec {
    /// The alignment to apply to grid rows and columns. The supported string values are `"all"`,
    /// `"each"`, and `"none"`.
    ///
    /// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
    /// one after the other.
    /// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
    /// column may be of variable size.
    /// - For `"all"`, subviews will be aligned and each row or column will be sized identically
    /// based on the maximum observed size. String values for this property will be applied to
    /// both grid rows and columns.
    ///
    /// Alternatively, an object value of the form `{"row": string, "column": string}` can be
    /// used to supply different alignments for rows and columns.
    ///
    /// __Default value:__ `"all"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Box<VegaliteAlign>>,
    /// The bounds calculation method to use for determining the extent of a sub-plot. One of
    /// `full` (the default) or `flush`.
    ///
    /// - If set to `full`, the entire calculated bounds (including axes, title, and legend) will
    /// be used.
    /// - If set to `flush`, only the specified width and height values for the sub-view will be
    /// used. The `flush` setting can be useful when attempting to place sub-plots without axes
    /// or legends into a uniform grid structure.
    ///
    /// __Default value:__ `"full"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bounds: Option<Box<Bounds>>,
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// An object value of the form `{"row": boolean, "column": boolean}` can be used to supply
    /// different centering values for rows and columns.
    ///
    /// __Default value:__ `false`
    ///
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<Box<Center>>,
    /// An object describing the data source. Set to `null` to ignore the parent's data source.
    /// If no data is set, it is derived from the parent.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub data: RemovableValue<UrlData>,
    /// Description of this mark for commenting purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<String>,
    /// A key-value mapping between encoding channels and definition of fields.
    ///
    /// A shared key-value mapping between encoding channels and definition of fields in the
    /// underlying layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<SpecEncoding>,
    /// The height of a visualization.
    ///
    /// - For a plot with a continuous y-field, height should be a number.
    /// - For a plot with either a discrete y-field or no y-field, height can be either a number
    /// indicating a fixed height or an object in the form of `{step: number}` defining the
    /// height per discrete step. (No y-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on height, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousHeight` for a plot with a continuous
    /// y-field and `config.view.discreteHeight` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// height of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`height`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<SpecHeight>,
    /// A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
    /// `"line"`, `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark
    /// definition object](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<AnyMark>,
    /// Name of the visualization for later reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An array of parameters that may either be simple variables, or more complex selections
    /// that map user input to data queries.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<Vec<SelectionParameter>>,
    /// An object defining properties of geographic projection, which will be applied to `shape`
    /// path for `"geoshape"` marks and to `latitude` and `"longitude"` channels for other
    /// marks.
    ///
    /// An object defining properties of the geographic projection shared by underlying layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection: Option<Box<Projection>>,
    /// Scale, axis, and legend resolutions for view composition specifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<Box<Resolve>>,
    /// The spacing in pixels between sub-views of the composition operator. An object of the
    /// form `{"row": number, "column": number}` can be used to set different spacing values for
    /// rows and columns.
    ///
    /// __Default value__: Depends on `"spacing"` property of [the view composition
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#view-config) (`20` by
    /// default)
    ///
    /// The spacing in pixels between sub-views of the concat operator.
    ///
    /// __Default value__: `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<Box<Spacing>>,
    /// Title for the plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title: Option<TitleUnion>,
    /// An array of data transformations such as filter and new field calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform: Option<Vec<Transform>>,
    /// An object defining the view background's fill and stroke.
    ///
    /// __Default value:__ none (transparent)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub view: Option<Box<ViewBackground>>,
    /// The width of a visualization.
    ///
    /// - For a plot with a continuous x-field, width should be a number.
    /// - For a plot with either a discrete x-field or no x-field, width can be either a number
    /// indicating a fixed width or an object in the form of `{step: number}` defining the width
    /// per discrete step. (No x-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on width, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousWidth` for a plot with a continuous
    /// x-field and `config.view.discreteWidth` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// width of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`width`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<SpecHeight>,
    /// Layer or single view specifications to be layered.
    ///
    /// __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
    /// layering facet specifications is not allowed. Instead, use the [facet
    /// operator](https://vega.github.io/vega-lite/docs/facet.html) and place a layer inside a
    /// facet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layer: Option<Vec<LayerSpec>>,
    /// The number of columns to include in the view composition layout.
    ///
    /// __Default value__: `undefined` -- An infinite number of columns (a single row) will be
    /// assumed. This is equivalent to `hconcat` (for `concat`) and to using the `column` channel
    /// (for `facet` and `repeat`).
    ///
    /// __Note__:
    ///
    /// 1) This property is only for:
    /// - the general (wrappable) `concat` operator (not `hconcat`/`vconcat`)
    /// - the `facet` and `repeat` operator with one field/repetition definition (without
    /// row/column nesting)
    ///
    /// 2) Setting the `columns` to `1` is equivalent to `vconcat` (for `concat`) and to using
    /// the `row` channel (for `facet` and `repeat`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<f64>,
    /// Definition for fields to be repeated. One of: 1) An array of fields to be repeated. If
    /// `"repeat"` is an array, the field can be referred to as `{"repeat": "repeat"}`. The
    /// repeated views are laid out in a wrapped row. You can set the number of columns to
    /// control the wrapping. 2) An object that maps `"row"` and/or `"column"` to the listed
    /// fields to be repeated along the particular orientations. The objects `{"repeat": "row"}`
    /// and `{"repeat": "column"}` can be used to refer to the repeated field respectively.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub repeat: Option<Box<RepeatUnion>>,
    /// A specification of the view that gets repeated.
    ///
    /// A specification of the view that gets faceted.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spec: Option<Box<SpecSpec>>,
    /// Definition for how to facet the data. One of: 1) [a field definition for faceting the
    /// plot by one field](https://vega.github.io/vega-lite/docs/facet.html#field-def) 2) [An
    /// object that maps `row` and `column` channels to their field
    /// definitions](https://vega.github.io/vega-lite/docs/facet.html#mapping)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<Box<Facet>>,
    /// A list of views to be concatenated.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub concat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a column.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub vconcat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a row.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hconcat: Option<Vec<Spec>>,
}

/// A specification of the view that gets repeated.
///
/// Any specification in Vega-Lite.
///
/// Unit spec that can have a composite mark and row or column channels (shorthand for a
/// facet spec).
///
/// A full layered plot specification, which may contains `encoding` and `projection`
/// properties that will be applied to underlying unit (single-view) specifications.
///
/// Base interface for a repeat specification.
///
/// Base interface for a facet specification.
///
/// Base interface for a generalized concatenation specification.
///
/// Base interface for a vertical concatenation specification.
///
/// Base interface for a horizontal concatenation specification.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Spec {
    /// The alignment to apply to grid rows and columns. The supported string values are `"all"`,
    /// `"each"`, and `"none"`.
    ///
    /// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
    /// one after the other.
    /// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
    /// column may be of variable size.
    /// - For `"all"`, subviews will be aligned and each row or column will be sized identically
    /// based on the maximum observed size. String values for this property will be applied to
    /// both grid rows and columns.
    ///
    /// Alternatively, an object value of the form `{"row": string, "column": string}` can be
    /// used to supply different alignments for rows and columns.
    ///
    /// __Default value:__ `"all"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Box<VegaliteAlign>>,
    /// The bounds calculation method to use for determining the extent of a sub-plot. One of
    /// `full` (the default) or `flush`.
    ///
    /// - If set to `full`, the entire calculated bounds (including axes, title, and legend) will
    /// be used.
    /// - If set to `flush`, only the specified width and height values for the sub-view will be
    /// used. The `flush` setting can be useful when attempting to place sub-plots without axes
    /// or legends into a uniform grid structure.
    ///
    /// __Default value:__ `"full"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bounds: Option<Box<Bounds>>,
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// An object value of the form `{"row": boolean, "column": boolean}` can be used to supply
    /// different centering values for rows and columns.
    ///
    /// __Default value:__ `false`
    ///
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<Box<Center>>,
    /// An object describing the data source. Set to `null` to ignore the parent's data source.
    /// If no data is set, it is derived from the parent.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub data: RemovableValue<UrlData>,
    /// Description of this mark for commenting purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<String>,
    /// A key-value mapping between encoding channels and definition of fields.
    ///
    /// A shared key-value mapping between encoding channels and definition of fields in the
    /// underlying layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<Box<EdEncoding>>,
    /// The height of a visualization.
    ///
    /// - For a plot with a continuous y-field, height should be a number.
    /// - For a plot with either a discrete y-field or no y-field, height can be either a number
    /// indicating a fixed height or an object in the form of `{step: number}` defining the
    /// height per discrete step. (No y-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on height, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousHeight` for a plot with a continuous
    /// y-field and `config.view.discreteHeight` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// height of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`height`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<SpecHeight>,
    /// A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
    /// `"line"`, `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark
    /// definition object](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<AnyMark>,
    /// Name of the visualization for later reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An array of parameters that may either be simple variables, or more complex selections
    /// that map user input to data queries.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<Vec<SelectionParameter>>,
    /// An object defining properties of geographic projection, which will be applied to `shape`
    /// path for `"geoshape"` marks and to `latitude` and `"longitude"` channels for other
    /// marks.
    ///
    /// An object defining properties of the geographic projection shared by underlying layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection: Option<Box<Projection>>,
    /// Scale, axis, and legend resolutions for view composition specifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<Box<Resolve>>,
    /// The spacing in pixels between sub-views of the composition operator. An object of the
    /// form `{"row": number, "column": number}` can be used to set different spacing values for
    /// rows and columns.
    ///
    /// __Default value__: Depends on `"spacing"` property of [the view composition
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#view-config) (`20` by
    /// default)
    ///
    /// The spacing in pixels between sub-views of the concat operator.
    ///
    /// __Default value__: `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<Box<Spacing>>,
    /// Title for the plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title: Option<TitleUnion>,
    /// An array of data transformations such as filter and new field calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform: Option<Vec<Transform>>,
    /// An object defining the view background's fill and stroke.
    ///
    /// __Default value:__ none (transparent)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub view: Option<Box<ViewBackground>>,
    /// The width of a visualization.
    ///
    /// - For a plot with a continuous x-field, width should be a number.
    /// - For a plot with either a discrete x-field or no x-field, width can be either a number
    /// indicating a fixed width or an object in the form of `{step: number}` defining the width
    /// per discrete step. (No x-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on width, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousWidth` for a plot with a continuous
    /// x-field and `config.view.discreteWidth` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// width of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`width`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<SpecHeight>,
    /// Layer or single view specifications to be layered.
    ///
    /// __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
    /// layering facet specifications is not allowed. Instead, use the [facet
    /// operator](https://vega.github.io/vega-lite/docs/facet.html) and place a layer inside a
    /// facet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layer: Option<Vec<LayerSpec>>,
    /// The number of columns to include in the view composition layout.
    ///
    /// __Default value__: `undefined` -- An infinite number of columns (a single row) will be
    /// assumed. This is equivalent to `hconcat` (for `concat`) and to using the `column` channel
    /// (for `facet` and `repeat`).
    ///
    /// __Note__:
    ///
    /// 1) This property is only for:
    /// - the general (wrappable) `concat` operator (not `hconcat`/`vconcat`)
    /// - the `facet` and `repeat` operator with one field/repetition definition (without
    /// row/column nesting)
    ///
    /// 2) Setting the `columns` to `1` is equivalent to `vconcat` (for `concat`) and to using
    /// the `row` channel (for `facet` and `repeat`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<f64>,
    /// Definition for fields to be repeated. One of: 1) An array of fields to be repeated. If
    /// `"repeat"` is an array, the field can be referred to as `{"repeat": "repeat"}`. The
    /// repeated views are laid out in a wrapped row. You can set the number of columns to
    /// control the wrapping. 2) An object that maps `"row"` and/or `"column"` to the listed
    /// fields to be repeated along the particular orientations. The objects `{"repeat": "row"}`
    /// and `{"repeat": "column"}` can be used to refer to the repeated field respectively.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub repeat: Option<Box<RepeatUnion>>,
    /// A specification of the view that gets repeated.
    ///
    /// A specification of the view that gets faceted.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spec: Option<Box<SpecSpec>>,
    /// Definition for how to facet the data. One of: 1) [a field definition for faceting the
    /// plot by one field](https://vega.github.io/vega-lite/docs/facet.html#field-def) 2) [An
    /// object that maps `row` and `column` channels to their field
    /// definitions](https://vega.github.io/vega-lite/docs/facet.html#mapping)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<Box<Facet>>,
    /// A list of views to be concatenated.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub concat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a column.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub vconcat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a row.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hconcat: Option<Vec<Spec>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct UrlData {
    /// An object that specifies the format for parsing the data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<DataFormat>,
    /// Provide a placeholder name and bind data at runtime.
    ///
    /// Provide a placeholder name and bind data at runtime.
    ///
    /// New data may change the layout but Vega does not always resize the chart. To update the
    /// layout when the data updates, set
    /// [autosize](https://vega.github.io/vega-lite/docs/size.html#autosize) or explicitly use
    /// [view.resize](https://vega.github.io/vega/docs/api/view/#view_resize).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An URL from which to load the data set. Use the `format.type` property to ensure the
    /// loaded data is correctly parsed.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<String>,
    /// The full data set, included inline. This can be an array of objects or primitive values,
    /// an object, or a string. Arrays of primitive values are ingested as objects with a `data`
    /// property. Strings are parsed according to the specified format type.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub values: Option<UrlDataInlineDataset>,
    /// Generate a sequence of numbers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sequence: Option<SequenceParams>,
    /// Generate sphere GeoJSON data for the full globe.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sphere: Option<SphereUnion>,
    /// Generate graticule GeoJSON data for geographic reference lines.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub graticule: Option<Graticule>,
}

/// An object that specifies the format for parsing the data.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DataFormat {
    /// If set to `null`, disable type inference based on the spec and only use type inference
    /// based on the data. Alternatively, a parsing directive object can be provided for explicit
    /// data types. Each property of the object corresponds to a field name, and the value to the
    /// desired data type (one of `"number"`, `"boolean"`, `"date"`, or null (do not parse the
    /// field)). For example, `"parse": {"modified_on": "date"}` parses the `modified_on` field
    /// in each input record a Date value.
    ///
    /// For `"date"`, we parse data based using JavaScript's
    /// [`Date.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse).
    /// For Specific date formats can be provided (e.g., `{foo: "date:'%m%d%Y'"}`), using the
    /// [d3-time-format syntax](https://github.com/d3/d3-time-format#locale_format). UTC date
    /// format parsing is supported similarly (e.g., `{foo: "utc:'%m%d%Y'"}`). See more about
    /// [UTC time](https://vega.github.io/vega-lite/docs/timeunit.html#utc)
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub parse: RemovableValue<HashMap<String, Option<String>>>,
    /// Type of input data: `"json"`, `"csv"`, `"tsv"`, `"dsv"`.
    ///
    /// __Default value:__  The default format type is determined by the extension of the file
    /// URL. If no extension is detected, `"json"` will be used by default.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub data_format_type: Option<DataFormatType>,
    /// The delimiter between records. 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.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub delimiter: Option<String>,
    /// The JSON property containing the desired data. This parameter can be used when the loaded
    /// JSON file may have surrounding structure or meta-data. For example `"property":
    /// "values.features"` is equivalent to retrieving `json.values.features` from the loaded
    /// JSON object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub property: Option<String>,
    /// The name of the TopoJSON object set to convert to a GeoJSON feature collection. For
    /// example, in a map of the world, there may be an object set named `"countries"`. Using the
    /// feature property, we can extract this set and generate a GeoJSON feature object for each
    /// country.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub feature: Option<String>,
    /// The name of the TopoJSON object set to convert to mesh. Similar to the `feature` option,
    /// `mesh` extracts a named TopoJSON object set.  Unlike the `feature` option, the
    /// corresponding geo data is returned as a single, unified mesh instance, not as individual
    /// GeoJSON features. Extracting a mesh is useful for more efficiently drawing borders or
    /// other geographic elements that you do not need to associate with specific regions such as
    /// individual countries, states or counties.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mesh: Option<String>,
}

/// Type of input data: `"json"`, `"csv"`, `"tsv"`, `"dsv"`.
///
/// __Default value:__  The default format type is determined by the extension of the file
/// URL. If no extension is detected, `"json"` will be used by default.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DataFormatType {
    Csv,
    Dsv,
    Json,
    Topojson,
    Tsv,
}

/// Generate graticule GeoJSON data for geographic reference lines.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Graticule {
    Bool(bool),
    GraticuleParams(GraticuleParams),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GraticuleParams {
    /// Sets both the major and minor extents to the same values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<Vec<Vec<f64>>>,
    /// The major extent of the graticule as a two-element array of coordinates.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent_major: Option<Vec<Vec<f64>>>,
    /// The minor extent of the graticule as a two-element array of coordinates.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent_minor: Option<Vec<Vec<f64>>>,
    /// The precision of the graticule in degrees.
    ///
    /// __Default value:__ `2.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub precision: Option<f64>,
    /// Sets both the major and minor step angles to the same values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<Vec<f64>>,
    /// The major step angles of the graticule.
    ///
    ///
    /// __Default value:__ `[90, 360]`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step_major: Option<Vec<f64>>,
    /// The minor step angles of the graticule.
    ///
    /// __Default value:__ `[10, 10]`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step_minor: Option<Vec<f64>>,
}

/// Generate a sequence of numbers.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SequenceParams {
    /// The name of the generated sequence field.
    ///
    /// __Default value:__ `"data"`
    #[serde(rename = "as")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sequence_params_as: Option<String>,
    /// The starting value of the sequence (inclusive).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start: Option<f64>,
    /// The step value between sequence entries.
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// The ending value of the sequence (exclusive).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stop: Option<f64>,
}

/// Generate sphere GeoJSON data for the full globe.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum SphereUnion {
    Bool(bool),
    SphereClass(SphereClass),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SphereClass {}

/// The full data set, included inline. This can be an array of objects or primitive values,
/// an object, or a string. Arrays of primitive values are ingested as objects with a `data`
/// property. Strings are parsed according to the specified format type.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum UrlDataInlineDataset {
    AnythingMap(HashMap<String, Option<serde_json::Value>>),
    String(String),
    UnionArray(Vec<serde_json::value::Value>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
#[allow(unused)]
enum UnusedInlineDataset {
    AnythingMap(HashMap<String, Option<serde_json::Value>>),
    Bool(bool),
    Double(f64),
    String(String),
}

/// A key-value mapping between encoding channels and definition of fields.
///
/// A shared key-value mapping between encoding channels and definition of fields in the
/// underlying layers.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SpecEncoding {
    /// Rotation angle of point and text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<AngleClass>,
    /// Color of the marks – either fill or stroke color based on  the `filled` property of mark
    /// definition. By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
    /// `"text"`, `"trail"`, `"circle"`, and `"square"` / stroke color for `"line"` and
    /// `"point"`.
    ///
    /// __Default value:__ If undefined, the default color depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ 1) For fine-grained control over both fill and stroke colors of the marks, please
    /// use the `fill` and `stroke` channels. The `fill` or `stroke` encodings have higher
    /// precedence than `color`, thus may override the `color` encoding if conflicting encodings
    /// are specified. 2) See the scale documentation for more information about customizing
    /// [color scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<ColorClass>,
    /// A field definition for the horizontal facet of trellis plots.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<RowColumnEncodingFieldDef>,
    /// A text description of this mark for ARIA accessibility (SVG output only). For SVG output
    /// the `"aria-label"` attribute will be set to this description.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<DescriptionClass>,
    /// Additional levels of detail for grouping data in aggregate views and in line, trail, and
    /// area marks without mapping data to a specific visual channel.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub detail: Option<Detail>,
    /// A field definition for the (flexible) facet of trellis plots.
    ///
    /// If either `row` or `column` is specified, this channel will be ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<FacetEncodingFieldDef>,
    /// Fill color of the marks. __Default value:__ If undefined, the default color depends on
    /// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ The `fill` encoding has higher precedence than `color`, thus may override the
    /// `color` encoding if conflicting encodings are specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<FillClass>,
    /// Fill opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<FillOpacityClass>,
    /// A URL to load upon mouse click.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<HrefClass>,
    /// A data field to use as a unique key for data binding. When a visualization’s data is
    /// updated, the key value will be used to match data elements to existing mark instances.
    /// Use a key channel to enable object constancy for transitions over dynamic data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub key: Option<KeyClass>,
    /// Latitude position of geographically projected marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub latitude: Option<LatitudeClass>,
    /// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
    /// `"rule"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub latitude2: Option<Latitude2Class>,
    /// Longitude position of geographically projected marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub longitude: Option<LongitudeClass>,
    /// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
    /// and  `"rule"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub longitude2: Option<Longitude2Class>,
    /// Opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<OpacityClass>,
    /// Order of the marks.
    /// - For stacked marks, this `order` channel encodes [stack
    /// order](https://vega.github.io/vega-lite/docs/stack.html#order).
    /// - For line and trail marks, this `order` channel encodes order of data points in the
    /// lines. This can be useful for creating [a connected
    /// scatterplot](https://vega.github.io/vega-lite/examples/connected_scatterplot.html).
    /// Setting `order` to `{"value": null}` makes the line marks use the original order in the
    /// data sources.
    /// - Otherwise, this `order` channel encodes layer order of the marks.
    ///
    /// __Note__: In aggregate plots, `order` field should be `aggregate`d to avoid creating
    /// additional aggregation grouping.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<Order>,
    /// The outer radius in pixels of arc marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<RadiusClass>,
    /// The inner radius in pixels of arc marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<Radius2Class>,
    /// A field definition for the vertical facet of trellis plots.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<RowColumnEncodingFieldDef>,
    /// Shape of the mark.
    ///
    /// 1. For `point` marks the supported values include:   - plotting shapes: `"circle"`,
    /// `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`, `"triangle-down"`,
    /// `"triangle-right"`, or `"triangle-left"`.   - the line symbol `"stroke"`   - centered
    /// directional shapes `"arrow"`, `"wedge"`, or `"triangle"`   - a custom [SVG path
    /// string](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths) (For correct
    /// sizing, custom shape paths should be defined within a square bounding box with
    /// coordinates ranging from -1 to 1 along both the x and y dimensions.)
    ///
    /// 2. For `geoshape` marks it should be a field definition of the geojson data
    ///
    /// __Default value:__ If undefined, the default shape depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#point-config)'s `shape`
    /// property. (`"circle"` if unset.)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<MarkPropDefStringNullTypeForShape>,
    /// Size of the mark.
    /// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
    /// - For `"bar"` and `"tick"` – the bar and tick's size.
    /// - For `"text"` – the text's font size.
    /// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
    /// line with varying size)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<SizeClass>,
    /// Stroke color of the marks. __Default value:__ If undefined, the default color depends on
    /// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ The `stroke` encoding has higher precedence than `color`, thus may override the
    /// `color` encoding if conflicting encodings are specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<StrokeClass>,
    /// Stroke dash of the marks.
    ///
    /// __Default value:__ `[1,0]` (No dash).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<MarkPropDefNumber>,
    /// Stroke opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<StrokeOpacityClass>,
    /// Stroke width of the marks.
    ///
    /// __Default value:__ If undefined, the default stroke width depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<StrokeWidthClass>,
    /// Text of the `text` mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<TextDef>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<ThetaClass>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<Theta2Class>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<TimeFieldDef>,
    /// The tooltip text to show upon mouse hover. Specifying `tooltip` encoding overrides [the
    /// `tooltip` property in the mark
    /// definition](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip in Vega-Lite.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<EncodingTooltip>,
    /// The URL of an image mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<UrlClass>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XClass>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<X2Class>,
    /// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_error: Option<XErrorClass>,
    /// Secondary error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_error2: Option<XError2Class>,
    /// Offset of x-position of the marks
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<XOffsetClass>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YClass>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<Y2Class>,
    /// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_error: Option<YErrorClass>,
    /// Secondary error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_error2: Option<YError2Class>,
    /// Offset of y-position of the marks
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<YOffsetClass>,
}

/// Rotation angle of point and text marks.
///
/// Fill opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
/// property.
///
/// Opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
/// property.
///
/// Size of the mark.
/// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
/// - For `"bar"` and `"tick"` – the bar and tick's size.
/// - For `"text"` – the text's font size.
/// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
/// line with varying size)
///
/// Stroke opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
/// property.
///
/// Stroke width of the marks.
///
/// __Default value:__ If undefined, the default stroke width depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
/// property.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AngleClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<AngleCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

/// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
/// `"max"`, `"count"`).
///
/// __Default value:__ `undefined` (None)
///
/// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
/// documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Aggregate {
    ArgmDef(ArgmDef),
    Enum(NonArgAggregateOp),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ArgmDef {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub argmax: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub argmin: Option<String>,
}

/// An [aggregate operation](https://vega.github.io/vega-lite/docs/aggregate.html#ops) to
/// perform on the field prior to sorting (e.g., `"count"`, `"mean"` and `"median"`). An
/// aggregation is required when there are multiple values of the sort field for each encoded
/// data field. The input data objects will be aggregated, grouped by the encoded data
/// field.
///
/// For a full list of operations, please see the documentation for
/// [aggregate](https://vega.github.io/vega-lite/docs/aggregate.html#ops).
///
/// __Default value:__ `"sum"` for stacked plots. Otherwise, `"min"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum NonArgAggregateOp {
    Average,
    Ci0,
    Ci1,
    Count,
    Distinct,
    Exponential,
    Exponentialb,
    Max,
    Mean,
    Median,
    Min,
    Missing,
    Product,
    Q1,
    Q3,
    Stderr,
    Stdev,
    Stdevp,
    Sum,
    Valid,
    Values,
    Variance,
    Variancep,
}

/// An object indicating bin properties, or simply `true` for using default bin parameters.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AngleBin {
    BinParams(BinParams),
    Bool(bool),
}

/// Binning properties or boolean flag for determining whether to bin data or not.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BinParams {
    /// A value in the binned domain at which to anchor the bins, shifting the bin boundaries if
    /// necessary to ensure that a boundary aligns with the anchor value.
    ///
    /// __Default value:__ the minimum bin extent value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub anchor: Option<f64>,
    /// The number base to use for automatic bin determination (default is base 10).
    ///
    /// __Default value:__ `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub base: Option<f64>,
    /// When set to `true`, Vega-Lite treats the input data as already binned.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub binned: Option<bool>,
    /// Scale factors indicating allowable subdivisions. The default value is [5, 2], which
    /// indicates that for base 10 numbers (the default base), the method may consider dividing
    /// bin sizes by 5 and/or 2. For example, for an initial step size of 10, the method can
    /// check if bin sizes of 2 (= 10/5), 5 (= 10/2), or 1 (= 10/(5*2)) might also satisfy the
    /// given constraints.
    ///
    /// __Default value:__ `[5, 2]`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub divide: Option<Vec<f64>>,
    /// A two-element (`[min, max]`) array indicating the range of desired bin values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<BinExtent>,
    /// Maximum number of bins.
    ///
    /// __Default value:__ `6` for `row`, `column` and `shape` channels; `10` for other channels
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub maxbins: Option<f64>,
    /// A minimum allowable step size (particularly useful for integer values).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minstep: Option<f64>,
    /// If true, attempts to make the bin boundaries use human-friendly boundaries, such as
    /// multiples of ten.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub nice: Option<bool>,
    /// An exact step size to use between bins.
    ///
    /// __Note:__ If provided, options such as maxbins will be ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// An array of allowable step sizes to choose from.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub steps: Option<Vec<f64>>,
}

/// A two-element (`[min, max]`) array indicating the range of desired bin values.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum BinExtent {
    BinExtentClass(BinExtentClass),
    DoubleArray(Vec<f64>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BinExtentClass {
    /// If a selection parameter is specified, the field name to extract selected values for when
    /// the selection is
    /// [projected](https://vega.github.io/vega-lite/docs/selection.html#project) over multiple
    /// fields or encodings.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// The name of a parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// If a selection parameter is specified, the encoding channel to extract selected values
    /// for when a selection is
    /// [projected](https://vega.github.io/vega-lite/docs/selection.html#project) over multiple
    /// fields or encodings.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<SingleDefUnitChannel>,
}

/// If a selection parameter is specified, the encoding channel to extract selected values
/// for when a selection is
/// [projected](https://vega.github.io/vega-lite/docs/selection.html#project) over multiple
/// fields or encodings.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SingleDefUnitChannel {
    Angle,
    Color,
    Description,
    Fill,
    #[serde(rename = "fillOpacity")]
    FillOpacity,
    Href,
    Key,
    Latitude,
    Latitude2,
    Longitude,
    Longitude2,
    Opacity,
    Radius,
    Radius2,
    Shape,
    Size,
    Stroke,
    #[serde(rename = "strokeDash")]
    StrokeDash,
    #[serde(rename = "strokeOpacity")]
    StrokeOpacity,
    #[serde(rename = "strokeWidth")]
    StrokeWidth,
    Text,
    Theta,
    Theta2,
    Time,
    Url,
    X,
    X2,
    #[serde(rename = "xOffset")]
    XOffset,
    Y,
    Y2,
    #[serde(rename = "yOffset")]
    YOffset,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AngleCondition {
    ConditionalPredicateValueDefNumberExprRefClass(ConditionalPredicateValueDefNumberExprRefClass),
    ConditionalValueDefNumberExprRefArray(Vec<ConditionalValueDefNumberExprRef>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalValueDefNumberExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefNumberExprRefValue>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

/// Predicate for triggering the condition
///
/// The `filter` property must be a predication definition, which can take one of the
/// following forms:
///
/// 1) an [expression](https://vega.github.io/vega-lite/docs/types.html#expression) string,
/// where `datum` can be used to refer to the current data object. For example, `{filter:
/// "datum.b2 > 60"}` would make the output data includes only items that have values in the
/// field `b2` over 60.
///
/// 2) one of the [field
/// predicates](https://vega.github.io/vega-lite/docs/predicate.html#field-predicate):
/// [`equal`](https://vega.github.io/vega-lite/docs/predicate.html#field-equal-predicate),
/// [`lt`](https://vega.github.io/vega-lite/docs/predicate.html#lt-predicate),
/// [`lte`](https://vega.github.io/vega-lite/docs/predicate.html#lte-predicate),
/// [`gt`](https://vega.github.io/vega-lite/docs/predicate.html#gt-predicate),
/// [`gte`](https://vega.github.io/vega-lite/docs/predicate.html#gte-predicate),
/// [`range`](https://vega.github.io/vega-lite/docs/predicate.html#range-predicate),
/// [`oneOf`](https://vega.github.io/vega-lite/docs/predicate.html#one-of-predicate), or
/// [`valid`](https://vega.github.io/vega-lite/docs/predicate.html#valid-predicate),
///
/// 3) a [selection
/// predicate](https://vega.github.io/vega-lite/docs/predicate.html#selection-predicate),
/// which define the names of a selection that the data point should belong to (or a logical
/// composition of selections).
///
/// 4) a [logical
/// composition](https://vega.github.io/vega-lite/docs/predicate.html#composition) of (1),
/// (2), or (3).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum PredicateCompositionElement {
    Predicate(Box<Predicate>),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Predicate {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub not: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub and: Option<Vec<PredicateCompositionElement>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub or: Option<Vec<PredicateCompositionElement>>,
    /// The value that the field should be equal to.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub equal: Option<Equal>,
    /// Field to be tested.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// Time unit for the field to be tested.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// An array of inclusive minimum and maximum values for a field value of a data item to be
    /// included in the filtered data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub range: Option<LogicalNotPredicateRange>,
    /// A set of values that the `field`'s value should be a member of, for a data item included
    /// in the filtered data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub one_of: Option<Vec<UnionWith>>,
    /// The value that the field should be less than.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub lt: Option<Lt>,
    /// The value that the field should be greater than.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gt: Option<Lt>,
    /// The value that the field should be less than or equals to.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub lte: Option<Lt>,
    /// The value that the field should be greater than or equals to.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gte: Option<Lt>,
    /// If set to true the field's value has to be valid, meaning both not `null` and not
    /// [`NaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub valid: Option<bool>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

/// Predicate for triggering the condition
///
/// The `filter` property must be a predication definition, which can take one of the
/// following forms:
///
/// 1) an [expression](https://vega.github.io/vega-lite/docs/types.html#expression) string,
/// where `datum` can be used to refer to the current data object. For example, `{filter:
/// "datum.b2 > 60"}` would make the output data includes only items that have values in the
/// field `b2` over 60.
///
/// 2) one of the [field
/// predicates](https://vega.github.io/vega-lite/docs/predicate.html#field-predicate):
/// [`equal`](https://vega.github.io/vega-lite/docs/predicate.html#field-equal-predicate),
/// [`lt`](https://vega.github.io/vega-lite/docs/predicate.html#lt-predicate),
/// [`lte`](https://vega.github.io/vega-lite/docs/predicate.html#lte-predicate),
/// [`gt`](https://vega.github.io/vega-lite/docs/predicate.html#gt-predicate),
/// [`gte`](https://vega.github.io/vega-lite/docs/predicate.html#gte-predicate),
/// [`range`](https://vega.github.io/vega-lite/docs/predicate.html#range-predicate),
/// [`oneOf`](https://vega.github.io/vega-lite/docs/predicate.html#one-of-predicate), or
/// [`valid`](https://vega.github.io/vega-lite/docs/predicate.html#valid-predicate),
///
/// 3) a [selection
/// predicate](https://vega.github.io/vega-lite/docs/predicate.html#selection-predicate),
/// which define the names of a selection that the data point should belong to (or a logical
/// composition of selections).
///
/// 4) a [logical
/// composition](https://vega.github.io/vega-lite/docs/predicate.html#composition) of (1),
/// (2), or (3).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalValueDefNumberExprRefPredicateComposition {
    Predicate(Box<Predicate>),
    String(String),
}

/// The value that the field should be equal to.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Equal {
    Bool(bool),
    Double(f64),
    EqualDateTime(EqualDateTime),
    String(String),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct EqualDateTime {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// Value representing the day of a week. This can be one of: (1) integer value -- `1`
/// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
/// case-insensitive, 3-character short day name (e.g., `"Mon"`).
///
/// **Warning:** A DateTime definition object with `day`** should not be combined with
/// `year`, `quarter`, `month`, or `date`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DayUnion {
    Double(f64),
    String(String),
}

/// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
/// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
/// short month name (e.g., `"Jan"`).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Month {
    Double(f64),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Lt {
    Double(f64),
    GtDateTime(GtDateTime),
    String(String),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GtDateTime {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum UnionWith {
    Bool(bool),
    DateTime(DateTime),
    Double(f64),
    String(String),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DateTime {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
}

/// An array of inclusive minimum and maximum values for a field value of a data item to be
/// included in the filtered data.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum LogicalNotPredicateRange {
    BackgroundExprRef(BackgroundExprRef),
    UnionArray(Vec<Option<PurpleRange>>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum PurpleRange {
    Double(f64),
    RangeDateTime(RangeDateTime),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RangeDateTime {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// Time unit for the field to be tested.
///
/// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
/// temporal field that gets casted as
/// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
///
/// __Default value:__ `undefined` (None)
///
/// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
/// documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum LogicalNotPredicateTimeUnit {
    Enum(BinnedTimeUnitEnum),
    TimeUnitParams(TimeUnitParams),
}

/// Time Unit Params for encoding predicate, which can specified if the data is  already
/// "binned".
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TimeUnitParams {
    /// Whether the data has already been binned to this time unit. If true, Vega-Lite will only
    /// format the data, marks, and guides, without applying the timeUnit transform to re-bin the
    /// data again.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub binned: Option<bool>,
    /// If no `unit` is specified, maxbins is used to infer time units.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub maxbins: Option<f64>,
    /// The number of steps between bins, in terms of the least significant unit provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// Defines how date-time values should be binned.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub unit: Option<TimeUnit>,
    /// True to use UTC timezone. Equivalent to using a `utc` prefixed `TimeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
}

/// Defines how date-time values should be binned.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TimeUnit {
    Date,
    Day,
    Dayhours,
    Dayhoursminutes,
    Dayhoursminutesseconds,
    Dayofyear,
    Hours,
    Hoursminutes,
    Hoursminutesseconds,
    Milliseconds,
    Minutes,
    Minutesseconds,
    Month,
    Monthdate,
    Monthdatehours,
    Monthdatehoursminutes,
    Monthdatehoursminutesseconds,
    Quarter,
    Quartermonth,
    Seconds,
    Secondsmilliseconds,
    Utcdate,
    Utcday,
    Utcdayhours,
    Utcdayhoursminutes,
    Utcdayhoursminutesseconds,
    Utcdayofyear,
    Utchours,
    Utchoursminutes,
    Utchoursminutesseconds,
    Utcmilliseconds,
    Utcminutes,
    Utcminutesseconds,
    Utcmonth,
    Utcmonthdate,
    Utcmonthdatehours,
    Utcmonthdatehoursminutes,
    Utcmonthdatehoursminutesseconds,
    Utcquarter,
    Utcquartermonth,
    Utcseconds,
    Utcsecondsmilliseconds,
    Utcweek,
    Utcweekday,
    Utcweekdayhours,
    Utcweekdayhoursminutes,
    Utcweekdayhoursminutesseconds,
    Utcyear,
    Utcyeardayofyear,
    Utcyearmonth,
    Utcyearmonthdate,
    Utcyearmonthdatehours,
    Utcyearmonthdatehoursminutes,
    Utcyearmonthdatehoursminutesseconds,
    Utcyearquarter,
    Utcyearquartermonth,
    Utcyearweek,
    Utcyearweekday,
    Utcyearweekdayhours,
    Utcyearweekdayhoursminutes,
    Utcyearweekdayhoursminutesseconds,
    Week,
    Weekday,
    Weekdayhours,
    Weekdayhoursminutes,
    Weekdayhoursminutesseconds,
    Year,
    Yeardayofyear,
    Yearmonth,
    Yearmonthdate,
    Yearmonthdatehours,
    Yearmonthdatehoursminutes,
    Yearmonthdatehoursminutesseconds,
    Yearquarter,
    Yearquartermonth,
    Yearweek,
    Yearweekday,
    Yearweekdayhours,
    Yearweekdayhoursminutes,
    Yearweekdayhoursminutesseconds,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BinnedTimeUnitEnum {
    Binnedutcyear,
    Binnedutcyeardayofyear,
    Binnedutcyearmonth,
    Binnedutcyearmonthdate,
    Binnedutcyearmonthdatehours,
    Binnedutcyearmonthdatehoursminutes,
    Binnedutcyearmonthdatehoursminutesseconds,
    Binnedutcyearquarter,
    Binnedutcyearquartermonth,
    Binnedutcyearweek,
    Binnedutcyearweekday,
    Binnedutcyearweekdayhours,
    Binnedutcyearweekdayhoursminutes,
    Binnedutcyearweekdayhoursminutesseconds,
    Binnedyear,
    Binnedyeardayofyear,
    Binnedyearmonth,
    Binnedyearmonthdate,
    Binnedyearmonthdatehours,
    Binnedyearmonthdatehoursminutes,
    Binnedyearmonthdatehoursminutesseconds,
    Binnedyearquarter,
    Binnedyearquartermonth,
    Binnedyearweek,
    Binnedyearweekday,
    Binnedyearweekdayhours,
    Binnedyearweekdayhoursminutes,
    Binnedyearweekdayhoursminutesseconds,
    Date,
    Day,
    Dayhours,
    Dayhoursminutes,
    Dayhoursminutesseconds,
    Dayofyear,
    Hours,
    Hoursminutes,
    Hoursminutesseconds,
    Milliseconds,
    Minutes,
    Minutesseconds,
    Month,
    Monthdate,
    Monthdatehours,
    Monthdatehoursminutes,
    Monthdatehoursminutesseconds,
    Quarter,
    Quartermonth,
    Seconds,
    Secondsmilliseconds,
    Utcdate,
    Utcday,
    Utcdayhours,
    Utcdayhoursminutes,
    Utcdayhoursminutesseconds,
    Utcdayofyear,
    Utchours,
    Utchoursminutes,
    Utchoursminutesseconds,
    Utcmilliseconds,
    Utcminutes,
    Utcminutesseconds,
    Utcmonth,
    Utcmonthdate,
    Utcmonthdatehours,
    Utcmonthdatehoursminutes,
    Utcmonthdatehoursminutesseconds,
    Utcquarter,
    Utcquartermonth,
    Utcseconds,
    Utcsecondsmilliseconds,
    Utcweek,
    Utcweekday,
    Utcweekdayhours,
    Utcweekdayhoursminutes,
    Utcweekdayhoursminutesseconds,
    Utcyear,
    Utcyeardayofyear,
    Utcyearmonth,
    Utcyearmonthdate,
    Utcyearmonthdatehours,
    Utcyearmonthdatehoursminutes,
    Utcyearmonthdatehoursminutesseconds,
    Utcyearquarter,
    Utcyearquartermonth,
    Utcyearweek,
    Utcyearweekday,
    Utcyearweekdayhours,
    Utcyearweekdayhoursminutes,
    Utcyearweekdayhoursminutesseconds,
    Week,
    Weekday,
    Weekdayhours,
    Weekdayhoursminutes,
    Weekdayhoursminutesseconds,
    Year,
    Yeardayofyear,
    Yearmonth,
    Yearmonthdate,
    Yearmonthdatehours,
    Yearmonthdatehoursminutes,
    Yearmonthdatehoursminutesseconds,
    Yearquarter,
    Yearquartermonth,
    Yearweek,
    Yearweekday,
    Yearweekdayhours,
    Yearweekdayhoursminutes,
    Yearweekdayhoursminutesseconds,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalValueDefNumberExprRefValue {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefNumberExprRefClass {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_value_def_number_expr_ref_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
/// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
/// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
///
/// Vega-Lite automatically infers data types in many cases as discussed below. However, type
/// is required for a field if: (1) the field is not nominal and the field encoding has no
/// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
/// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
/// or `timeUnit`.
///
/// __Default value:__
///
/// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
/// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
/// following criteria:
/// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
/// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
/// `longitude` channel or (3) if the specified scale type is [a quantitative
/// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
/// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
/// the specified scale type is a time or utc scale
/// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
/// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
/// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
/// `order`.
///
/// 2) For a constant value in data domain (`datum`):
/// - `"quantitative"` if the datum is a number
/// - `"nominal"` if the datum is a string
/// - `"temporal"` if the datum is [a date time
/// object](https://vega.github.io/vega-lite/docs/datetime.html)
///
/// __Note:__
/// - Data `type` describes the semantics of the data rather than the primitive data types
/// (number, string, etc.). The same primitive data type can have different types of
/// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
/// data.
/// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
/// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
/// `1552199579097`).
/// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
/// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
/// (for using an ordinal bin
/// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
/// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
/// `type` property can be either `"temporal"` (default, for using a temporal scale) or
/// [`"ordinal"` (for using an ordinal
/// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
/// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
/// the `type` property refers to the post-aggregation data type. For example, we can
/// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
/// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
/// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
/// must have exactly the same type as their primary channels (e.g., `x`, `y`).
///
/// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
///
/// Data type based on level of measurement
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Type {
    Geojson,
    Nominal,
    Ordinal,
    Quantitative,
    Temporal,
}

/// A constant value in data domain.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum PrimitiveValue {
    Bool(bool),
    Double(f64),
    RepeatRefClass(RepeatRefClass),
    String(String),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
///
/// Reference to a repeated value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RepeatRefClass {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub repeat: Option<RepeatEnum>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RepeatEnum {
    Column,
    Layer,
    Repeat,
    Row,
}

/// __Required.__ A string defining the name of the field from which to pull a data value or
/// an object defining iterated values from the
/// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
///
/// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
///
/// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
/// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
/// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
/// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
/// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
/// required if `aggregate` is `count`.
///
/// The data [field](https://vega.github.io/vega-lite/docs/field.html) to sort by.
///
/// __Default value:__ If unspecified, defaults to the field specified in the outer data
/// reference.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Field {
    RepeatRef(RepeatRef),
    String(String),
}

/// Reference to a repeated value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RepeatRef {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub repeat: Option<RepeatEnum>,
}

/// Properties of a legend or boolean flag for determining whether to show it.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Legend {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    /// The direction of the legend, one of `"vertical"` or `"horizontal"`.
    ///
    /// __Default value:__
    /// - For top-/bottom-`orient`ed legends, `"horizontal"`
    /// - For left-/right-`orient`ed legends, `"vertical"`
    /// - For top/bottom-left/right-`orient`ed legends, `"horizontal"` for gradient legends and
    /// `"vertical"` for symbol legends.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub direction: Option<Orientation>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_color: Option<Box<Color>>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_length: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_thickness: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_align: Option<GridAlign>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<Box<Color>>,
    /// [Vega expression](https://vega.github.io/vega/docs/expressions/) for customizing labels.
    ///
    /// __Note:__ The label text and value can be assessed via the `label` and `value` properties
    /// of the legend's backing `datum` object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_offset: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_overlap: Option<LabelOverlapUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_separation: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend_x: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend_y: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    /// The orientation of the legend, which determines how the legend is positioned within the
    /// scene. One of `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
    /// `"bottom-left"`, `"bottom-right"`, `"none"`.
    ///
    /// __Default value:__ `"right"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<LegendOrient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_fill_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_type: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_count: Option<TickCount>,
    /// The minimum desired step between legend ticks, in terms of scale domain values. For
    /// example, a value of `1` indicates that ticks should not be less than 1 unit apart. If
    /// `tickMinStep` is specified, the `tickCount` value will be adjusted, if necessary, to
    /// enforce the minimum step value.
    ///
    /// __Default value__: `undefined`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_min_step: Option<CornerRadiusUnion>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_orient: Option<TitleOrientUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
    /// The type of the legend. Use `"symbol"` to create a discrete legend and `"gradient"` for a
    /// continuous color gradient.
    ///
    /// __Default value:__ `"gradient"` for non-binned quantitative fields and temporal fields;
    /// `"symbol"` otherwise.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend_type: Option<LegendType>,
    /// Explicitly set the visible legend values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub values: Option<Values>,
    /// A non-negative integer indicating the z-index of the legend. If zindex is 0, legend
    /// should be drawn behind all chart elements. To put them in front, use zindex = 1.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Aria {
    BackgroundExprRef(BackgroundExprRef),
    Bool(bool),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum CornerRadiusUnion {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
}

/// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
/// horizontal (default) or vertical.
/// - For bar, rule and tick, this determines whether the size of the bar and tick should be
/// applied to x or y dimension.
/// - For area, this property determines the orient property of the Vega output.
/// - For line and trail marks, this property determines the sort order of the points in the
/// line if `config.sortLineBy` is not specified. For stacked charts, this is always
/// determined by the orientation of the stack; therefore explicitly specified value will be
/// ignored.
///
/// The direction of the legend, one of `"vertical"` or `"horizontal"`.
///
/// __Default value:__
/// - For top-/bottom-`orient`ed legends, `"horizontal"`
/// - For left-/right-`orient`ed legends, `"vertical"`
/// - For top/bottom-left/right-`orient`ed legends, `"horizontal"` for gradient legends and
/// `"vertical"` for symbol legends.
///
/// The default direction (`"horizontal"` or `"vertical"`) for gradient legends.
///
/// __Default value:__ `"vertical"`.
///
/// The default direction (`"horizontal"` or `"vertical"`) for symbol legends.
///
/// __Default value:__ `"vertical"`.
///
/// Orientation of the box plot. This is normally automatically determined based on types of
/// fields on x and y channels. However, an explicit `orient` be specified when the
/// orientation is ambiguous.
///
/// __Default value:__ `"vertical"`.
///
/// Orientation of the error bar. This is normally automatically determined, but can be
/// specified when the orientation is ambiguous and cannot be automatically determined.
///
/// Orientation of the error band. This is normally automatically determined, but can be
/// specified when the orientation is ambiguous and cannot be automatically determined.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Orientation {
    Horizontal,
    Vertical,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Format {
    AnythingMap(HashMap<String, Option<serde_json::Value>>),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FontSize {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum GridAlign {
    BackgroundExprRef(BackgroundExprRef),
    Enum(LayoutAlign),
}

/// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
/// of `"left"`, `"right"`, `"center"`.
///
/// __Note:__ Expression reference is *not* supported for range marks.
///
/// Horizontal text alignment of header labels. One of `"left"`, `"center"`, or `"right"`.
///
/// Horizontal text alignment (to the anchor) of header titles.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TitleAlignUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(Align),
}

/// Horizontal text alignment of axis tick labels, overriding the default setting for the
/// current axis orientation.
///
/// Horizontal text alignment of axis titles.
///
/// The alignment of the legend label, can be left, center, or right.
///
/// Horizontal text alignment for legend titles.
///
/// __Default value:__ `"left"`.
///
/// Horizontal text alignment for title text. One of `"left"`, `"center"`, or `"right"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Align {
    Center,
    Left,
    Right,
}

/// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
/// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
/// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
/// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
/// rather than `fontSize` alone.
///
/// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
/// `"bottom"`.
///
/// __Note:__ Expression reference is *not* supported for range marks.
///
/// The vertical text baseline for the header labels. One of `"alphabetic"` (default),
/// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
/// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
/// relative to the `titleLineHeight` rather than `titleFontSize` alone.
///
/// The vertical text baseline for the header title. One of `"alphabetic"` (default),
/// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
/// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
/// relative to the `titleLineHeight` rather than `titleFontSize` alone.
///
/// __Default value:__ `"middle"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TextBaseline {
    BackgroundExprRef(BackgroundExprRef),
    Enum(Baseline),
}

/// Vertical text baseline of axis tick labels, overriding the default setting for the
/// current axis orientation. One of `"alphabetic"` (default), `"top"`, `"middle"`,
/// `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and `"line-bottom"` values
/// operate similarly to `"top"` and `"bottom"`, but are calculated relative to the
/// *lineHeight* rather than *fontSize* alone.
///
/// Vertical text baseline for axis titles. One of `"alphabetic"` (default), `"top"`,
/// `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
/// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
/// relative to the *lineHeight* rather than *fontSize* alone.
///
/// The position of the baseline of legend label, can be `"top"`, `"middle"`, `"bottom"`, or
/// `"alphabetic"`.
///
/// __Default value:__ `"middle"`.
///
/// Vertical text baseline for legend titles.  One of `"alphabetic"` (default), `"top"`,
/// `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
/// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
/// relative to the *lineHeight* rather than *fontSize* alone.
///
/// __Default value:__ `"top"`.
///
/// Vertical text baseline for title and subtitle text. One of `"alphabetic"` (default),
/// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
/// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
/// relative to the *lineHeight* rather than *fontSize* alone.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Baseline {
    Alphabetic,
    Bottom,
    #[serde(rename = "line-bottom")]
    LineBottom,
    #[serde(rename = "line-top")]
    LineTop,
    Middle,
    Top,
}

/// The font weight of the header label.
///
/// Font weight of the header title. This can be either a string (e.g `"bold"`, `"normal"`)
/// or a number (`100`, `200`, `300`, ..., `900` where `"normal"` = `400` and `"bold"` =
/// `700`).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FontWeightUnion {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
    Enum(FontWeightEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FontWeightEnum {
    Bold,
    Bolder,
    Lighter,
    Normal,
}

/// The strategy to use for resolving overlap of axis labels. If `false` (the default), no
/// overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
/// every other label is used (this works well for standard linear axes). If set to
/// `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
/// with the last visible label (this often works better for log-scaled axes).
///
/// __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
/// scales; otherwise `false`.
///
/// The strategy to use for resolving overlap of labels in gradient legends. If `false`, no
/// overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
/// every other label is used. If set to `"greedy"`, a linear scan of the labels is
/// performed, removing any label that overlaps with the last visible label (this often works
/// better for log-scaled axes).
///
/// __Default value:__ `"greedy"` for `log scales otherwise `true`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum LabelOverlapUnion {
    BackgroundExprRef(BackgroundExprRef),
    Bool(bool),
    Enum(LabelOverlapEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LabelOverlapEnum {
    Greedy,
    Parity,
}

/// The type of the legend. Use `"symbol"` to create a discrete legend and `"gradient"` for a
/// continuous color gradient.
///
/// __Default value:__ `"gradient"` for non-binned quantitative fields and temporal fields;
/// `"symbol"` otherwise.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LegendType {
    Gradient,
    Symbol,
}

/// The orientation of the legend, which determines how the legend is positioned within the
/// scene. One of `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
/// `"bottom-left"`, `"bottom-right"`, `"none"`.
///
/// __Default value:__ `"right"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum LegendOrient {
    Bottom,
    #[serde(rename = "bottom-left")]
    BottomLeft,
    #[serde(rename = "bottom-right")]
    BottomRight,
    Left,
    None,
    Right,
    Top,
    #[serde(rename = "top-left")]
    TopLeft,
    #[serde(rename = "top-right")]
    TopRight,
}

/// The projection’s translation offset as a two-element array `[tx, ty]`.
///
/// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
/// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
/// between `0` to `1` for opacity).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum StrokeDashUnion {
    BackgroundExprRef(BackgroundExprRef),
    DoubleArray(Vec<f64>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TickCount {
    Double(f64),
    Enum(TimeInterval),
    TickCountTimeIntervalStep(TickCountTimeIntervalStep),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TickCountTimeIntervalStep {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interval: Option<TimeInterval>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TimeInterval {
    Day,
    Hour,
    Millisecond,
    Minute,
    Month,
    Second,
    Week,
    Year,
}

/// A string or array of strings indicating the name of custom styles to apply to the mark. A
/// style is a named collection of mark property defaults defined within the [style
/// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
/// an array, later styles will override earlier styles. Any [mark
/// properties](https://vega.github.io/vega-lite/docs/encoding.html#mark-prop) explicitly
/// defined within the `encoding` will override a style default.
///
/// __Default value:__ The mark's name. For example, a bar mark will have style `"bar"` by
/// default. __Note:__ Any specified style will augment the default style. For example, a bar
/// mark with `"style": "foo"` will receive from `config.style.bar` and `config.style.foo`
/// (the specified style `"foo"` has higher precedence).
///
/// A string or array of strings indicating the name of custom styles to apply to the axis. A
/// style is a named collection of axis property defined within the [style
/// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
/// an array, later styles will override earlier styles.
///
/// __Default value:__ (none) __Note:__ Any specified style will augment the default style.
/// For example, an x-axis mark with `"style": "foo"` will use `config.axisX` and
/// `config.style.foo` (the specified style `"foo"` has higher precedence).
///
/// A [mark style property](https://vega.github.io/vega-lite/docs/config.html#style) to apply
/// to the title text mark.
///
/// __Default value:__ `"group-title"`.
///
/// Placeholder text if the `text` channel is not specified
///
/// The subtitle Text.
///
/// A string or array of strings indicating the name of custom styles to apply to the view
/// background. A style is a named collection of mark property defaults defined within the
/// [style configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If
/// style is an array, later styles will override earlier styles.
///
/// __Default value:__ `"cell"` __Note:__ Any specified view background properties will
/// augment the default style.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum LegendText {
    String(String),
    StringArray(Vec<String>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TitleAnchorUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(TitleAnchorEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TitleAnchorEnum {
    End,
    Middle,
    Start,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TitleOrientUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(Orient),
}

/// The orientation of the header label. One of `"top"`, `"bottom"`, `"left"` or `"right"`.
///
/// Shortcut for setting both labelOrient and titleOrient.
///
/// The orientation of the header title. One of `"top"`, `"bottom"`, `"left"` or `"right"`.
///
/// Orientation of the legend title.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Orient {
    Bottom,
    Left,
    Right,
    Top,
}

/// Explicitly set the visible axis tick values.
///
/// Explicitly set the visible legend values.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Values {
    BackgroundExprRef(BackgroundExprRef),
    UnionArray(Vec<UnionWith>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Scale {
    /// The alignment of the steps within the scale range.
    ///
    /// This value must lie in the range `[0,1]`. A value of `0.5` indicates that the steps
    /// should be centered within the range. A value of `0` or `1` may be used to shift the bands
    /// to one side, say to position them adjacent to an axis.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<CornerRadiusUnion>,
    /// The logarithm base of the `log` scale (default `10`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub base: Option<CornerRadiusUnion>,
    /// Bin boundaries can be provided to scales as either an explicit array of bin boundaries or
    /// as a bin specification object. The legal values are:
    /// - An [array](../types/#Array) literal of bin boundary values. For example, `[0, 5, 10,
    /// 15, 20]`. The array must include both starting and ending boundaries. The previous
    /// example uses five values to indicate a total of four bin intervals: [0-5), [5-10),
    /// [10-15), [15-20]. Array literals may include signal references as elements.
    /// - A [bin specification object](https://vega.github.io/vega-lite/docs/scale.html#bins)
    /// that indicates the bin _step_ size, and optionally the _start_ and _stop_ boundaries.
    /// - An array of bin boundaries over the scale domain. If provided, axes and legends will
    /// use the bin boundaries to inform the choice of tick marks and text labels.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bins: Option<ScaleBins>,
    /// If `true`, values that exceed the data domain are clamped to either the minimum or
    /// maximum range value
    ///
    /// __Default value:__ derived from the [scale
    /// config](https://vega.github.io/vega-lite/docs/config.html#scale-config)'s `clamp` (`true`
    /// by default).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clamp: Option<Aria>,
    /// A constant determining the slope of the symlog function around zero. Only used for
    /// `symlog` scales.
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub constant: Option<CornerRadiusUnion>,
    /// Customized domain values in the form of constant values or dynamic values driven by a
    /// parameter.
    ///
    /// 1) Constant `domain` for _quantitative_ fields can take one of the following forms:
    ///
    /// - A two-element array with minimum and maximum values. To create a diverging scale, this
    /// two-element array can be combined with the `domainMid` property.
    /// - An array with more than two entries, for [Piecewise quantitative
    /// scales](https://vega.github.io/vega-lite/docs/scale.html#piecewise).
    /// - A string value `"unaggregated"`, if the input field is aggregated, to indicate that the
    /// domain should include the raw data values prior to the aggregation.
    ///
    /// 2) Constant `domain` for _temporal_ fields can be a two-element array with minimum and
    /// maximum values, in the form of either timestamps or the [DateTime definition
    /// objects](https://vega.github.io/vega-lite/docs/types.html#datetime).
    ///
    /// 3) Constant `domain` for _ordinal_ and _nominal_ fields can be an array that lists valid
    /// input values.
    ///
    /// 4) To combine (union) specified constant domain with the field's values, `domain` can be
    /// an object with a `unionWith` property that specify constant domain to be combined. For
    /// example, `domain: {unionWith: [0, 100]}` for a quantitative scale means that the scale
    /// domain always includes `[0, 100]`, but will include other values in the fields beyond
    /// `[0, 100]`.
    ///
    /// 5) Domain can also takes an object defining a field or encoding of a parameter that
    /// [interactively
    /// determines](https://vega.github.io/vega-lite/docs/selection.html#scale-domains) the scale
    /// domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain: Option<DomainUnion>,
    /// Sets the maximum value in the scale domain, overriding the `domain` property. This
    /// property is only intended for use with scales having continuous domains.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_max: Option<DomainM>,
    /// Inserts a single mid-point value into a two-element domain. The mid-point value must lie
    /// between the domain minimum and maximum values. This property can be useful for setting a
    /// midpoint for [diverging color
    /// scales](https://vega.github.io/vega-lite/docs/scale.html#piecewise). The domainMid
    /// property is only intended for use with scales supporting continuous, piecewise domains.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_mid: Option<CornerRadiusUnion>,
    /// Sets the minimum value in the scale domain, overriding the domain property. This property
    /// is only intended for use with scales having continuous domains.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_min: Option<DomainM>,
    /// An expression for an array of raw values that, if non-null, directly overrides the
    /// _domain_ property. This is useful for supporting interactions such as panning or zooming
    /// a scale. The scale may be initially determined using a data-driven domain, then modified
    /// in response to user input by setting the rawDomain value.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_raw: Option<BackgroundExprRef>,
    /// The exponent of the `pow` scale.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub exponent: Option<CornerRadiusUnion>,
    /// The interpolation method for range values. By default, a general interpolator for
    /// numbers, dates, strings and colors (in HCL space) is used. For color ranges, this
    /// property allows interpolation in alternative color spaces. Legal values include `rgb`,
    /// `hsl`, `hsl-long`, `lab`, `hcl`, `hcl-long`, `cubehelix` and `cubehelix-long` ('-long'
    /// variants use longer paths in polar coordinate spaces). If object-valued, this property
    /// accepts an object with a string-valued _type_ property and an optional numeric _gamma_
    /// property applicable to rgb and cubehelix interpolators. For more, see the [d3-interpolate
    /// documentation](https://github.com/d3/d3-interpolate).
    ///
    /// * __Default value:__ `hcl`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<ScaleInterpolate>,
    /// Extending the domain so that it starts and ends on nice round values. This method
    /// typically modifies the scale’s domain, and may only extend the bounds to the nearest
    /// round value. Nicing is useful if the domain is computed from data and may be irregular.
    /// For example, for a domain of _[0.201479…, 0.996679…]_, a nice domain might be _[0.2,
    /// 1.0]_.
    ///
    /// For quantitative scales such as linear, `nice` can be either a boolean flag or a number.
    /// If `nice` is a number, it will represent a desired tick count. This allows greater
    /// control over the step size used to extend the bounds, guaranteeing that the returned
    /// ticks will exactly cover the domain.
    ///
    /// For temporal fields with time and utc scales, the `nice` value can be a string indicating
    /// the desired time interval. Legal values are `"millisecond"`, `"second"`, `"minute"`,
    /// `"hour"`, `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, `time` and `utc`
    /// scales can accept an object-valued interval specifier of the form `{"interval": "month",
    /// "step": 3}`, which includes a desired number of interval steps. Here, the domain would
    /// snap to quarter (Jan, Apr, Jul, Oct) boundaries.
    ///
    /// __Default value:__ `true` for unbinned _quantitative_ fields without explicit domain
    /// bounds; `false` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub nice: Option<Nice>,
    /// For _[continuous](https://vega.github.io/vega-lite/docs/scale.html#continuous)_ scales,
    /// expands the scale domain to accommodate the specified number of pixels on each of the
    /// scale range. The scale range must represent pixels for this parameter to function as
    /// intended. Padding adjustment is performed prior to all other adjustments, including the
    /// effects of the `zero`, `nice`, `domainMin`, and `domainMax` properties.
    ///
    /// For _[band](https://vega.github.io/vega-lite/docs/scale.html#band)_ scales, shortcut for
    /// setting `paddingInner` and `paddingOuter` to the same value.
    ///
    /// For _[point](https://vega.github.io/vega-lite/docs/scale.html#point)_ scales, alias for
    /// `paddingOuter`.
    ///
    /// __Default value:__ For _continuous_ scales, derived from the [scale
    /// config](https://vega.github.io/vega-lite/docs/scale.html#config)'s `continuousPadding`.
    /// For _band and point_ scales, see `paddingInner` and `paddingOuter`. By default, Vega-Lite
    /// sets padding such that _width/height = number of unique values * step_.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding: Option<CornerRadiusUnion>,
    /// The inner padding (spacing) within each band step of band scales, as a fraction of the
    /// step size. This value must lie in the range [0,1].
    ///
    /// For point scale, this property is invalid as point scales do not have internal band
    /// widths (only step sizes between bands).
    ///
    /// __Default value:__ derived from the [scale
    /// config](https://vega.github.io/vega-lite/docs/scale.html#config)'s `bandPaddingInner`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding_inner: Option<CornerRadiusUnion>,
    /// The outer padding (spacing) at the ends of the range of band and point scales, as a
    /// fraction of the step size. This value must lie in the range [0,1].
    ///
    /// __Default value:__ derived from the [scale
    /// config](https://vega.github.io/vega-lite/docs/scale.html#config)'s `bandPaddingOuter` for
    /// band scales and `pointPadding` for point scales. By default, Vega-Lite sets outer padding
    /// such that _width/height = number of unique values * step_.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding_outer: Option<CornerRadiusUnion>,
    /// The range of the scale. One of:
    ///
    /// - A string indicating a [pre-defined named scale
    /// range](https://vega.github.io/vega-lite/docs/scale.html#range-config) (e.g., example,
    /// `"symbol"`, or `"diverging"`).
    ///
    /// - For [continuous scales](https://vega.github.io/vega-lite/docs/scale.html#continuous),
    /// two-element array indicating  minimum and maximum values, or an array with more than two
    /// entries for specifying a [piecewise
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#piecewise).
    ///
    /// - For [discrete](https://vega.github.io/vega-lite/docs/scale.html#discrete) and
    /// [discretizing](https://vega.github.io/vega-lite/docs/scale.html#discretizing) scales, an
    /// array of desired output values or an object with a `field` property representing the
    /// range values.  For example, if a field `color` contains CSS color names, we can set
    /// `range` to `{field: "color"}`.
    ///
    /// __Notes:__
    ///
    /// 1) For color scales you can also specify a color
    /// [`scheme`](https://vega.github.io/vega-lite/docs/scale.html#scheme) instead of `range`.
    ///
    /// 2) Any directly specified `range` for `x` and `y` channels will be ignored. Range can be
    /// customized via the view's corresponding
    /// [size](https://vega.github.io/vega-lite/docs/size.html) (`width` and `height`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub range: Option<ScaleRange>,
    /// Sets the maximum value in the scale range, overriding the `range` property or the default
    /// range. This property is only intended for use with scales having continuous ranges.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub range_max: Option<RangeM>,
    /// Sets the minimum value in the scale range, overriding the `range` property or the default
    /// range. This property is only intended for use with scales having continuous ranges.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub range_min: Option<RangeM>,
    /// If true, reverses the order of the scale range. __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub reverse: Option<Aria>,
    /// If `true`, rounds numeric output values to integers. This can be helpful for snapping to
    /// the pixel grid.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub round: Option<Aria>,
    /// A string indicating a color
    /// [scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme) name (e.g.,
    /// `"category10"` or `"blues"`) or a [scheme parameter
    /// object](https://vega.github.io/vega-lite/docs/scale.html#scheme-params).
    ///
    /// Discrete color schemes may be used with
    /// [discrete](https://vega.github.io/vega-lite/docs/scale.html#discrete) or
    /// [discretizing](https://vega.github.io/vega-lite/docs/scale.html#discretizing) scales.
    /// Continuous color schemes are intended for use with color scales.
    ///
    /// To set a custom scheme, instead set the list of values [as the scale
    /// range](https://vega.github.io/vega-lite/docs/scale.html#2-setting-the-range-property-to-an-array-of-valid-css-color-strings).
    ///
    /// For the full list of supported schemes, please refer to the [Vega
    /// Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub scheme: Option<SchemeUnion>,
    /// The type of scale. Vega-Lite supports the following categories of scale types:
    ///
    /// 1) [**Continuous Scales**](https://vega.github.io/vega-lite/docs/scale.html#continuous)
    /// -- mapping continuous domains to continuous output ranges
    /// ([`"linear"`](https://vega.github.io/vega-lite/docs/scale.html#linear),
    /// [`"pow"`](https://vega.github.io/vega-lite/docs/scale.html#pow),
    /// [`"sqrt"`](https://vega.github.io/vega-lite/docs/scale.html#sqrt),
    /// [`"symlog"`](https://vega.github.io/vega-lite/docs/scale.html#symlog),
    /// [`"log"`](https://vega.github.io/vega-lite/docs/scale.html#log),
    /// [`"time"`](https://vega.github.io/vega-lite/docs/scale.html#time),
    /// [`"utc"`](https://vega.github.io/vega-lite/docs/scale.html#utc).
    ///
    /// 2) [**Discrete Scales**](https://vega.github.io/vega-lite/docs/scale.html#discrete) --
    /// mapping discrete domains to discrete
    /// ([`"ordinal"`](https://vega.github.io/vega-lite/docs/scale.html#ordinal)) or continuous
    /// ([`"band"`](https://vega.github.io/vega-lite/docs/scale.html#band) and
    /// [`"point"`](https://vega.github.io/vega-lite/docs/scale.html#point)) output ranges.
    ///
    /// 3) [**Discretizing
    /// Scales**](https://vega.github.io/vega-lite/docs/scale.html#discretizing) -- mapping
    /// continuous domains to discrete output ranges
    /// [`"bin-ordinal"`](https://vega.github.io/vega-lite/docs/scale.html#bin-ordinal),
    /// [`"quantile"`](https://vega.github.io/vega-lite/docs/scale.html#quantile),
    /// [`"quantize"`](https://vega.github.io/vega-lite/docs/scale.html#quantize) and
    /// [`"threshold"`](https://vega.github.io/vega-lite/docs/scale.html#threshold).
    ///
    /// __Default value:__ please see the [scale type
    /// table](https://vega.github.io/vega-lite/docs/scale.html#type).
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub scale_type: Option<ScaleType>,
    /// If `true`, ensures that a zero baseline value is included in the scale domain.
    ///
    /// __Default value:__ `true` for x and y channels if the quantitative field is not binned
    /// and no custom `domain` is provided; `false` otherwise.
    ///
    /// __Note:__ Log, time, and utc scales do not support `zero`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zero: Option<Aria>,
}

/// Bin boundaries can be provided to scales as either an explicit array of bin boundaries or
/// as a bin specification object. The legal values are:
/// - An [array](../types/#Array) literal of bin boundary values. For example, `[0, 5, 10,
/// 15, 20]`. The array must include both starting and ending boundaries. The previous
/// example uses five values to indicate a total of four bin intervals: [0-5), [5-10),
/// [10-15), [15-20]. Array literals may include signal references as elements.
/// - A [bin specification object](https://vega.github.io/vega-lite/docs/scale.html#bins)
/// that indicates the bin _step_ size, and optionally the _start_ and _stop_ boundaries.
/// - An array of bin boundaries over the scale domain. If provided, axes and legends will
/// use the bin boundaries to inform the choice of tick marks and text labels.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleBins {
    DoubleArray(Vec<f64>),
    ScaleBinParams(ScaleBinParams),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleBinParams {
    /// The starting (lowest-valued) bin boundary.
    ///
    /// __Default value:__ The lowest value of the scale domain will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start: Option<f64>,
    /// The step size defining the bin interval width.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// The stopping (highest-valued) bin boundary.
    ///
    /// __Default value:__ The highest value of the scale domain will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stop: Option<f64>,
}

/// Customized domain values in the form of constant values or dynamic values driven by a
/// parameter.
///
/// 1) Constant `domain` for _quantitative_ fields can take one of the following forms:
///
/// - A two-element array with minimum and maximum values. To create a diverging scale, this
/// two-element array can be combined with the `domainMid` property.
/// - An array with more than two entries, for [Piecewise quantitative
/// scales](https://vega.github.io/vega-lite/docs/scale.html#piecewise).
/// - A string value `"unaggregated"`, if the input field is aggregated, to indicate that the
/// domain should include the raw data values prior to the aggregation.
///
/// 2) Constant `domain` for _temporal_ fields can be a two-element array with minimum and
/// maximum values, in the form of either timestamps or the [DateTime definition
/// objects](https://vega.github.io/vega-lite/docs/types.html#datetime).
///
/// 3) Constant `domain` for _ordinal_ and _nominal_ fields can be an array that lists valid
/// input values.
///
/// 4) To combine (union) specified constant domain with the field's values, `domain` can be
/// an object with a `unionWith` property that specify constant domain to be combined. For
/// example, `domain: {unionWith: [0, 100]}` for a quantitative scale means that the scale
/// domain always includes `[0, 100]`, but will include other values in the fields beyond
/// `[0, 100]`.
///
/// 5) Domain can also takes an object defining a field or encoding of a parameter that
/// [interactively
/// determines](https://vega.github.io/vega-lite/docs/selection.html#scale-domains) the scale
/// domain.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DomainUnion {
    DomainUnionWith(DomainUnionWith),
    Enum(DomainEnum),
    UnionArray(Vec<Option<DomainElement>>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DomainElement {
    Bool(bool),
    DomainDateTime(DomainDateTime),
    Double(f64),
    String(String),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DomainDateTime {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DomainUnionWith {
    /// If a selection parameter is specified, the field name to extract selected values for when
    /// the selection is
    /// [projected](https://vega.github.io/vega-lite/docs/selection.html#project) over multiple
    /// fields or encodings.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// The name of a parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// If a selection parameter is specified, the encoding channel to extract selected values
    /// for when a selection is
    /// [projected](https://vega.github.io/vega-lite/docs/selection.html#project) over multiple
    /// fields or encodings.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<SingleDefUnitChannel>,
    /// Customized domain values to be union with the field's values or explicitly defined
    /// domain. Should be an array of valid scale domain values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub union_with: Option<Vec<UnionWith>>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DomainEnum {
    Unaggregated,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DomainM {
    DomainMaxDateTime(DomainMaxDateTime),
    Double(f64),
}

/// Object for defining datetime in Vega-Lite Filter. If both month and quarter are provided,
/// month has higher precedence. `day` cannot be combined with other date. We accept string
/// for month and day names.
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DomainMaxDateTime {
    /// Integer value representing the date (day of the month) from 1-31.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<f64>,
    /// Value representing the day of a week. This can be one of: (1) integer value -- `1`
    /// represents Monday; (2) case-insensitive day name (e.g., `"Monday"`); (3)
    /// case-insensitive, 3-character short day name (e.g., `"Mon"`).
    ///
    /// **Warning:** A DateTime definition object with `day`** should not be combined with
    /// `year`, `quarter`, `month`, or `date`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub day: Option<DayUnion>,
    /// Integer value representing the hour of a day from 0-23.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hours: Option<f64>,
    /// Integer value representing the millisecond segment of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub milliseconds: Option<f64>,
    /// Integer value representing the minute segment of time from 0-59.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minutes: Option<f64>,
    /// One of: (1) integer value representing the month from `1`-`12`. `1` represents January;
    /// (2) case-insensitive month name (e.g., `"January"`); (3) case-insensitive, 3-character
    /// short month name (e.g., `"Jan"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub month: Option<Month>,
    /// Integer value representing the quarter of the year (from 1-4).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quarter: Option<f64>,
    /// Integer value representing the second segment (0-59) of a time value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub seconds: Option<f64>,
    /// A boolean flag indicating if date time is in utc time. If false, the date time is in
    /// local time
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
    /// Integer value representing the year.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub year: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// The interpolation method for range values. By default, a general interpolator for
/// numbers, dates, strings and colors (in HCL space) is used. For color ranges, this
/// property allows interpolation in alternative color spaces. Legal values include `rgb`,
/// `hsl`, `hsl-long`, `lab`, `hcl`, `hcl-long`, `cubehelix` and `cubehelix-long` ('-long'
/// variants use longer paths in polar coordinate spaces). If object-valued, this property
/// accepts an object with a string-valued _type_ property and an optional numeric _gamma_
/// property applicable to rgb and cubehelix interpolators. For more, see the [d3-interpolate
/// documentation](https://github.com/d3/d3-interpolate).
///
/// * __Default value:__ `hcl`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInterpolate {
    Enum(ScaleInterpolateEnum),
    ScaleInterpolateParamsClass(ScaleInterpolateParamsClass),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInterpolateParamsClass {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gamma: Option<f64>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr_ref_type: Option<ScaleInterpolateParamsType>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ScaleInterpolateParamsType {
    Cubehelix,
    #[serde(rename = "cubehelix-long")]
    CubehelixLong,
    Rgb,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ScaleInterpolateEnum {
    Cubehelix,
    #[serde(rename = "cubehelix-long")]
    CubehelixLong,
    Hcl,
    #[serde(rename = "hcl-long")]
    HclLong,
    Hsl,
    #[serde(rename = "hsl-long")]
    HslLong,
    Lab,
    Rgb,
}

/// Extending the domain so that it starts and ends on nice round values. This method
/// typically modifies the scale’s domain, and may only extend the bounds to the nearest
/// round value. Nicing is useful if the domain is computed from data and may be irregular.
/// For example, for a domain of _[0.201479…, 0.996679…]_, a nice domain might be _[0.2,
/// 1.0]_.
///
/// For quantitative scales such as linear, `nice` can be either a boolean flag or a number.
/// If `nice` is a number, it will represent a desired tick count. This allows greater
/// control over the step size used to extend the bounds, guaranteeing that the returned
/// ticks will exactly cover the domain.
///
/// For temporal fields with time and utc scales, the `nice` value can be a string indicating
/// the desired time interval. Legal values are `"millisecond"`, `"second"`, `"minute"`,
/// `"hour"`, `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, `time` and `utc`
/// scales can accept an object-valued interval specifier of the form `{"interval": "month",
/// "step": 3}`, which includes a desired number of interval steps. Here, the domain would
/// snap to quarter (Jan, Apr, Jul, Oct) boundaries.
///
/// __Default value:__ `true` for unbinned _quantitative_ fields without explicit domain
/// bounds; `false` otherwise.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Nice {
    Bool(bool),
    Double(f64),
    Enum(TimeInterval),
    NiceTimeIntervalStep(NiceTimeIntervalStep),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct NiceTimeIntervalStep {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interval: Option<TimeInterval>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// The range of the scale. One of:
///
/// - A string indicating a [pre-defined named scale
/// range](https://vega.github.io/vega-lite/docs/scale.html#range-config) (e.g., example,
/// `"symbol"`, or `"diverging"`).
///
/// - For [continuous scales](https://vega.github.io/vega-lite/docs/scale.html#continuous),
/// two-element array indicating  minimum and maximum values, or an array with more than two
/// entries for specifying a [piecewise
/// scale](https://vega.github.io/vega-lite/docs/scale.html#piecewise).
///
/// - For [discrete](https://vega.github.io/vega-lite/docs/scale.html#discrete) and
/// [discretizing](https://vega.github.io/vega-lite/docs/scale.html#discretizing) scales, an
/// array of desired output values or an object with a `field` property representing the
/// range values.  For example, if a field `color` contains CSS color names, we can set
/// `range` to `{field: "color"}`.
///
/// __Notes:__
///
/// 1) For color scales you can also specify a color
/// [`scheme`](https://vega.github.io/vega-lite/docs/scale.html#scheme) instead of `range`.
///
/// 2) Any directly specified `range` for `x` and `y` channels will be ignored. Range can be
/// customized via the view's corresponding
/// [size](https://vega.github.io/vega-lite/docs/size.html) (`width` and `height`).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleRange {
    Enum(RangeEnum),
    FieldRange(FieldRange),
    UnionArray(Vec<FluffyRange>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FluffyRange {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
    DoubleArray(Vec<f64>),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FieldRange {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RangeEnum {
    Category,
    Diverging,
    Heatmap,
    Height,
    Ordinal,
    Ramp,
    Symbol,
    Width,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum RangeM {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
    String(String),
}

/// The type of scale. Vega-Lite supports the following categories of scale types:
///
/// 1) [**Continuous Scales**](https://vega.github.io/vega-lite/docs/scale.html#continuous)
/// -- mapping continuous domains to continuous output ranges
/// ([`"linear"`](https://vega.github.io/vega-lite/docs/scale.html#linear),
/// [`"pow"`](https://vega.github.io/vega-lite/docs/scale.html#pow),
/// [`"sqrt"`](https://vega.github.io/vega-lite/docs/scale.html#sqrt),
/// [`"symlog"`](https://vega.github.io/vega-lite/docs/scale.html#symlog),
/// [`"log"`](https://vega.github.io/vega-lite/docs/scale.html#log),
/// [`"time"`](https://vega.github.io/vega-lite/docs/scale.html#time),
/// [`"utc"`](https://vega.github.io/vega-lite/docs/scale.html#utc).
///
/// 2) [**Discrete Scales**](https://vega.github.io/vega-lite/docs/scale.html#discrete) --
/// mapping discrete domains to discrete
/// ([`"ordinal"`](https://vega.github.io/vega-lite/docs/scale.html#ordinal)) or continuous
/// ([`"band"`](https://vega.github.io/vega-lite/docs/scale.html#band) and
/// [`"point"`](https://vega.github.io/vega-lite/docs/scale.html#point)) output ranges.
///
/// 3) [**Discretizing
/// Scales**](https://vega.github.io/vega-lite/docs/scale.html#discretizing) -- mapping
/// continuous domains to discrete output ranges
/// [`"bin-ordinal"`](https://vega.github.io/vega-lite/docs/scale.html#bin-ordinal),
/// [`"quantile"`](https://vega.github.io/vega-lite/docs/scale.html#quantile),
/// [`"quantize"`](https://vega.github.io/vega-lite/docs/scale.html#quantize) and
/// [`"threshold"`](https://vega.github.io/vega-lite/docs/scale.html#threshold).
///
/// __Default value:__ please see the [scale type
/// table](https://vega.github.io/vega-lite/docs/scale.html#type).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ScaleType {
    Band,
    #[serde(rename = "bin-ordinal")]
    BinOrdinal,
    Identity,
    Linear,
    Log,
    Ordinal,
    Point,
    Pow,
    Quantile,
    Quantize,
    Sequential,
    Sqrt,
    Symlog,
    Threshold,
    Time,
    Utc,
}

/// A string indicating a color
/// [scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme) name (e.g.,
/// `"category10"` or `"blues"`) or a [scheme parameter
/// object](https://vega.github.io/vega-lite/docs/scale.html#scheme-params).
///
/// Discrete color schemes may be used with
/// [discrete](https://vega.github.io/vega-lite/docs/scale.html#discrete) or
/// [discretizing](https://vega.github.io/vega-lite/docs/scale.html#discretizing) scales.
/// Continuous color schemes are intended for use with color scales.
///
/// To set a custom scheme, instead set the list of values [as the scale
/// range](https://vega.github.io/vega-lite/docs/scale.html#2-setting-the-range-property-to-an-array-of-valid-css-color-strings).
///
/// For the full list of supported schemes, please refer to the [Vega
/// Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum SchemeUnion {
    Enum(ColorScheme),
    SchemeParams(SchemeParams),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SchemeParams {
    /// The number of colors to use in the scheme. This can be useful for scale types such as
    /// `"quantize"`, which use the length of the scale range to determine the number of discrete
    /// bins for the scale domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub count: Option<f64>,
    /// The extent of the color range to use. For example `[0.2, 1]` will rescale the color
    /// scheme such that color values in the range _[0, 0.2)_ are excluded from the scheme.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<Vec<f64>>,
    /// A color scheme name for ordinal scales (e.g., `"category10"` or `"blues"`).
    ///
    /// For the full list of supported schemes, please refer to the [Vega
    /// Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<ColorScheme>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// A color scheme name for ordinal scales (e.g., `"category10"` or `"blues"`).
///
/// For the full list of supported schemes, please refer to the [Vega
/// Scheme](https://vega.github.io/vega/docs/schemes/#reference) reference.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ColorScheme {
    Accent,
    Bluegreen,
    #[serde(rename = "bluegreen-3")]
    Bluegreen3,
    #[serde(rename = "bluegreen-4")]
    Bluegreen4,
    #[serde(rename = "bluegreen-5")]
    Bluegreen5,
    #[serde(rename = "bluegreen-6")]
    Bluegreen6,
    #[serde(rename = "bluegreen-7")]
    Bluegreen7,
    #[serde(rename = "bluegreen-8")]
    Bluegreen8,
    #[serde(rename = "bluegreen-9")]
    Bluegreen9,
    Blueorange,
    #[serde(rename = "blueorange-10")]
    Blueorange10,
    #[serde(rename = "blueorange-11")]
    Blueorange11,
    #[serde(rename = "blueorange-3")]
    Blueorange3,
    #[serde(rename = "blueorange-4")]
    Blueorange4,
    #[serde(rename = "blueorange-5")]
    Blueorange5,
    #[serde(rename = "blueorange-6")]
    Blueorange6,
    #[serde(rename = "blueorange-7")]
    Blueorange7,
    #[serde(rename = "blueorange-8")]
    Blueorange8,
    #[serde(rename = "blueorange-9")]
    Blueorange9,
    Bluepurple,
    #[serde(rename = "bluepurple-3")]
    Bluepurple3,
    #[serde(rename = "bluepurple-4")]
    Bluepurple4,
    #[serde(rename = "bluepurple-5")]
    Bluepurple5,
    #[serde(rename = "bluepurple-6")]
    Bluepurple6,
    #[serde(rename = "bluepurple-7")]
    Bluepurple7,
    #[serde(rename = "bluepurple-8")]
    Bluepurple8,
    #[serde(rename = "bluepurple-9")]
    Bluepurple9,
    Blues,
    Brownbluegreen,
    #[serde(rename = "brownbluegreen-10")]
    Brownbluegreen10,
    #[serde(rename = "brownbluegreen-11")]
    Brownbluegreen11,
    #[serde(rename = "brownbluegreen-3")]
    Brownbluegreen3,
    #[serde(rename = "brownbluegreen-4")]
    Brownbluegreen4,
    #[serde(rename = "brownbluegreen-5")]
    Brownbluegreen5,
    #[serde(rename = "brownbluegreen-6")]
    Brownbluegreen6,
    #[serde(rename = "brownbluegreen-7")]
    Brownbluegreen7,
    #[serde(rename = "brownbluegreen-8")]
    Brownbluegreen8,
    #[serde(rename = "brownbluegreen-9")]
    Brownbluegreen9,
    Browns,
    Category10,
    Category20,
    Category20B,
    Category20C,
    Cividis,
    Dark2,
    Darkblue,
    #[serde(rename = "darkblue-3")]
    Darkblue3,
    #[serde(rename = "darkblue-4")]
    Darkblue4,
    #[serde(rename = "darkblue-5")]
    Darkblue5,
    #[serde(rename = "darkblue-6")]
    Darkblue6,
    #[serde(rename = "darkblue-7")]
    Darkblue7,
    #[serde(rename = "darkblue-8")]
    Darkblue8,
    #[serde(rename = "darkblue-9")]
    Darkblue9,
    Darkgold,
    #[serde(rename = "darkgold-3")]
    Darkgold3,
    #[serde(rename = "darkgold-4")]
    Darkgold4,
    #[serde(rename = "darkgold-5")]
    Darkgold5,
    #[serde(rename = "darkgold-6")]
    Darkgold6,
    #[serde(rename = "darkgold-7")]
    Darkgold7,
    #[serde(rename = "darkgold-8")]
    Darkgold8,
    #[serde(rename = "darkgold-9")]
    Darkgold9,
    Darkgreen,
    #[serde(rename = "darkgreen-3")]
    Darkgreen3,
    #[serde(rename = "darkgreen-4")]
    Darkgreen4,
    #[serde(rename = "darkgreen-5")]
    Darkgreen5,
    #[serde(rename = "darkgreen-6")]
    Darkgreen6,
    #[serde(rename = "darkgreen-7")]
    Darkgreen7,
    #[serde(rename = "darkgreen-8")]
    Darkgreen8,
    #[serde(rename = "darkgreen-9")]
    Darkgreen9,
    Darkmulti,
    #[serde(rename = "darkmulti-3")]
    Darkmulti3,
    #[serde(rename = "darkmulti-4")]
    Darkmulti4,
    #[serde(rename = "darkmulti-5")]
    Darkmulti5,
    #[serde(rename = "darkmulti-6")]
    Darkmulti6,
    #[serde(rename = "darkmulti-7")]
    Darkmulti7,
    #[serde(rename = "darkmulti-8")]
    Darkmulti8,
    #[serde(rename = "darkmulti-9")]
    Darkmulti9,
    Darkred,
    #[serde(rename = "darkred-3")]
    Darkred3,
    #[serde(rename = "darkred-4")]
    Darkred4,
    #[serde(rename = "darkred-5")]
    Darkred5,
    #[serde(rename = "darkred-6")]
    Darkred6,
    #[serde(rename = "darkred-7")]
    Darkred7,
    #[serde(rename = "darkred-8")]
    Darkred8,
    #[serde(rename = "darkred-9")]
    Darkred9,
    Goldgreen,
    #[serde(rename = "goldgreen-3")]
    Goldgreen3,
    #[serde(rename = "goldgreen-4")]
    Goldgreen4,
    #[serde(rename = "goldgreen-5")]
    Goldgreen5,
    #[serde(rename = "goldgreen-6")]
    Goldgreen6,
    #[serde(rename = "goldgreen-7")]
    Goldgreen7,
    #[serde(rename = "goldgreen-8")]
    Goldgreen8,
    #[serde(rename = "goldgreen-9")]
    Goldgreen9,
    Goldorange,
    #[serde(rename = "goldorange-3")]
    Goldorange3,
    #[serde(rename = "goldorange-4")]
    Goldorange4,
    #[serde(rename = "goldorange-5")]
    Goldorange5,
    #[serde(rename = "goldorange-6")]
    Goldorange6,
    #[serde(rename = "goldorange-7")]
    Goldorange7,
    #[serde(rename = "goldorange-8")]
    Goldorange8,
    #[serde(rename = "goldorange-9")]
    Goldorange9,
    Goldred,
    #[serde(rename = "goldred-3")]
    Goldred3,
    #[serde(rename = "goldred-4")]
    Goldred4,
    #[serde(rename = "goldred-5")]
    Goldred5,
    #[serde(rename = "goldred-6")]
    Goldred6,
    #[serde(rename = "goldred-7")]
    Goldred7,
    #[serde(rename = "goldred-8")]
    Goldred8,
    #[serde(rename = "goldred-9")]
    Goldred9,
    Greenblue,
    #[serde(rename = "greenblue-3")]
    Greenblue3,
    #[serde(rename = "greenblue-4")]
    Greenblue4,
    #[serde(rename = "greenblue-5")]
    Greenblue5,
    #[serde(rename = "greenblue-6")]
    Greenblue6,
    #[serde(rename = "greenblue-7")]
    Greenblue7,
    #[serde(rename = "greenblue-8")]
    Greenblue8,
    #[serde(rename = "greenblue-9")]
    Greenblue9,
    Greens,
    Greys,
    Inferno,
    Lightgreyred,
    #[serde(rename = "lightgreyred-3")]
    Lightgreyred3,
    #[serde(rename = "lightgreyred-4")]
    Lightgreyred4,
    #[serde(rename = "lightgreyred-5")]
    Lightgreyred5,
    #[serde(rename = "lightgreyred-6")]
    Lightgreyred6,
    #[serde(rename = "lightgreyred-7")]
    Lightgreyred7,
    #[serde(rename = "lightgreyred-8")]
    Lightgreyred8,
    #[serde(rename = "lightgreyred-9")]
    Lightgreyred9,
    Lightgreyteal,
    #[serde(rename = "lightgreyteal-3")]
    Lightgreyteal3,
    #[serde(rename = "lightgreyteal-4")]
    Lightgreyteal4,
    #[serde(rename = "lightgreyteal-5")]
    Lightgreyteal5,
    #[serde(rename = "lightgreyteal-6")]
    Lightgreyteal6,
    #[serde(rename = "lightgreyteal-7")]
    Lightgreyteal7,
    #[serde(rename = "lightgreyteal-8")]
    Lightgreyteal8,
    #[serde(rename = "lightgreyteal-9")]
    Lightgreyteal9,
    Lightmulti,
    #[serde(rename = "lightmulti-3")]
    Lightmulti3,
    #[serde(rename = "lightmulti-4")]
    Lightmulti4,
    #[serde(rename = "lightmulti-5")]
    Lightmulti5,
    #[serde(rename = "lightmulti-6")]
    Lightmulti6,
    #[serde(rename = "lightmulti-7")]
    Lightmulti7,
    #[serde(rename = "lightmulti-8")]
    Lightmulti8,
    #[serde(rename = "lightmulti-9")]
    Lightmulti9,
    Lightorange,
    #[serde(rename = "lightorange-3")]
    Lightorange3,
    #[serde(rename = "lightorange-4")]
    Lightorange4,
    #[serde(rename = "lightorange-5")]
    Lightorange5,
    #[serde(rename = "lightorange-6")]
    Lightorange6,
    #[serde(rename = "lightorange-7")]
    Lightorange7,
    #[serde(rename = "lightorange-8")]
    Lightorange8,
    #[serde(rename = "lightorange-9")]
    Lightorange9,
    Lighttealblue,
    #[serde(rename = "lighttealblue-3")]
    Lighttealblue3,
    #[serde(rename = "lighttealblue-4")]
    Lighttealblue4,
    #[serde(rename = "lighttealblue-5")]
    Lighttealblue5,
    #[serde(rename = "lighttealblue-6")]
    Lighttealblue6,
    #[serde(rename = "lighttealblue-7")]
    Lighttealblue7,
    #[serde(rename = "lighttealblue-8")]
    Lighttealblue8,
    #[serde(rename = "lighttealblue-9")]
    Lighttealblue9,
    Magma,
    Observable10,
    Orangered,
    #[serde(rename = "orangered-3")]
    Orangered3,
    #[serde(rename = "orangered-4")]
    Orangered4,
    #[serde(rename = "orangered-5")]
    Orangered5,
    #[serde(rename = "orangered-6")]
    Orangered6,
    #[serde(rename = "orangered-7")]
    Orangered7,
    #[serde(rename = "orangered-8")]
    Orangered8,
    #[serde(rename = "orangered-9")]
    Orangered9,
    Oranges,
    Paired,
    Pastel1,
    Pastel2,
    Pinkyellowgreen,
    #[serde(rename = "pinkyellowgreen-10")]
    Pinkyellowgreen10,
    #[serde(rename = "pinkyellowgreen-11")]
    Pinkyellowgreen11,
    #[serde(rename = "pinkyellowgreen-3")]
    Pinkyellowgreen3,
    #[serde(rename = "pinkyellowgreen-4")]
    Pinkyellowgreen4,
    #[serde(rename = "pinkyellowgreen-5")]
    Pinkyellowgreen5,
    #[serde(rename = "pinkyellowgreen-6")]
    Pinkyellowgreen6,
    #[serde(rename = "pinkyellowgreen-7")]
    Pinkyellowgreen7,
    #[serde(rename = "pinkyellowgreen-8")]
    Pinkyellowgreen8,
    #[serde(rename = "pinkyellowgreen-9")]
    Pinkyellowgreen9,
    Plasma,
    Purpleblue,
    #[serde(rename = "purpleblue-3")]
    Purpleblue3,
    #[serde(rename = "purpleblue-4")]
    Purpleblue4,
    #[serde(rename = "purpleblue-5")]
    Purpleblue5,
    #[serde(rename = "purpleblue-6")]
    Purpleblue6,
    #[serde(rename = "purpleblue-7")]
    Purpleblue7,
    #[serde(rename = "purpleblue-8")]
    Purpleblue8,
    #[serde(rename = "purpleblue-9")]
    Purpleblue9,
    Purplebluegreen,
    #[serde(rename = "purplebluegreen-3")]
    Purplebluegreen3,
    #[serde(rename = "purplebluegreen-4")]
    Purplebluegreen4,
    #[serde(rename = "purplebluegreen-5")]
    Purplebluegreen5,
    #[serde(rename = "purplebluegreen-6")]
    Purplebluegreen6,
    #[serde(rename = "purplebluegreen-7")]
    Purplebluegreen7,
    #[serde(rename = "purplebluegreen-8")]
    Purplebluegreen8,
    #[serde(rename = "purplebluegreen-9")]
    Purplebluegreen9,
    Purplegreen,
    #[serde(rename = "purplegreen-10")]
    Purplegreen10,
    #[serde(rename = "purplegreen-11")]
    Purplegreen11,
    #[serde(rename = "purplegreen-3")]
    Purplegreen3,
    #[serde(rename = "purplegreen-4")]
    Purplegreen4,
    #[serde(rename = "purplegreen-5")]
    Purplegreen5,
    #[serde(rename = "purplegreen-6")]
    Purplegreen6,
    #[serde(rename = "purplegreen-7")]
    Purplegreen7,
    #[serde(rename = "purplegreen-8")]
    Purplegreen8,
    #[serde(rename = "purplegreen-9")]
    Purplegreen9,
    Purpleorange,
    #[serde(rename = "purpleorange-10")]
    Purpleorange10,
    #[serde(rename = "purpleorange-11")]
    Purpleorange11,
    #[serde(rename = "purpleorange-3")]
    Purpleorange3,
    #[serde(rename = "purpleorange-4")]
    Purpleorange4,
    #[serde(rename = "purpleorange-5")]
    Purpleorange5,
    #[serde(rename = "purpleorange-6")]
    Purpleorange6,
    #[serde(rename = "purpleorange-7")]
    Purpleorange7,
    #[serde(rename = "purpleorange-8")]
    Purpleorange8,
    #[serde(rename = "purpleorange-9")]
    Purpleorange9,
    Purplered,
    #[serde(rename = "purplered-3")]
    Purplered3,
    #[serde(rename = "purplered-4")]
    Purplered4,
    #[serde(rename = "purplered-5")]
    Purplered5,
    #[serde(rename = "purplered-6")]
    Purplered6,
    #[serde(rename = "purplered-7")]
    Purplered7,
    #[serde(rename = "purplered-8")]
    Purplered8,
    #[serde(rename = "purplered-9")]
    Purplered9,
    Purples,
    Rainbow,
    Redblue,
    #[serde(rename = "redblue-10")]
    Redblue10,
    #[serde(rename = "redblue-11")]
    Redblue11,
    #[serde(rename = "redblue-3")]
    Redblue3,
    #[serde(rename = "redblue-4")]
    Redblue4,
    #[serde(rename = "redblue-5")]
    Redblue5,
    #[serde(rename = "redblue-6")]
    Redblue6,
    #[serde(rename = "redblue-7")]
    Redblue7,
    #[serde(rename = "redblue-8")]
    Redblue8,
    #[serde(rename = "redblue-9")]
    Redblue9,
    Redgrey,
    #[serde(rename = "redgrey-10")]
    Redgrey10,
    #[serde(rename = "redgrey-11")]
    Redgrey11,
    #[serde(rename = "redgrey-3")]
    Redgrey3,
    #[serde(rename = "redgrey-4")]
    Redgrey4,
    #[serde(rename = "redgrey-5")]
    Redgrey5,
    #[serde(rename = "redgrey-6")]
    Redgrey6,
    #[serde(rename = "redgrey-7")]
    Redgrey7,
    #[serde(rename = "redgrey-8")]
    Redgrey8,
    #[serde(rename = "redgrey-9")]
    Redgrey9,
    Redpurple,
    #[serde(rename = "redpurple-3")]
    Redpurple3,
    #[serde(rename = "redpurple-4")]
    Redpurple4,
    #[serde(rename = "redpurple-5")]
    Redpurple5,
    #[serde(rename = "redpurple-6")]
    Redpurple6,
    #[serde(rename = "redpurple-7")]
    Redpurple7,
    #[serde(rename = "redpurple-8")]
    Redpurple8,
    #[serde(rename = "redpurple-9")]
    Redpurple9,
    Reds,
    Redyellowblue,
    #[serde(rename = "redyellowblue-10")]
    Redyellowblue10,
    #[serde(rename = "redyellowblue-11")]
    Redyellowblue11,
    #[serde(rename = "redyellowblue-3")]
    Redyellowblue3,
    #[serde(rename = "redyellowblue-4")]
    Redyellowblue4,
    #[serde(rename = "redyellowblue-5")]
    Redyellowblue5,
    #[serde(rename = "redyellowblue-6")]
    Redyellowblue6,
    #[serde(rename = "redyellowblue-7")]
    Redyellowblue7,
    #[serde(rename = "redyellowblue-8")]
    Redyellowblue8,
    #[serde(rename = "redyellowblue-9")]
    Redyellowblue9,
    Redyellowgreen,
    #[serde(rename = "redyellowgreen-10")]
    Redyellowgreen10,
    #[serde(rename = "redyellowgreen-11")]
    Redyellowgreen11,
    #[serde(rename = "redyellowgreen-3")]
    Redyellowgreen3,
    #[serde(rename = "redyellowgreen-4")]
    Redyellowgreen4,
    #[serde(rename = "redyellowgreen-5")]
    Redyellowgreen5,
    #[serde(rename = "redyellowgreen-6")]
    Redyellowgreen6,
    #[serde(rename = "redyellowgreen-7")]
    Redyellowgreen7,
    #[serde(rename = "redyellowgreen-8")]
    Redyellowgreen8,
    #[serde(rename = "redyellowgreen-9")]
    Redyellowgreen9,
    Set1,
    Set2,
    Set3,
    Sinebow,
    Spectral,
    #[serde(rename = "spectral-10")]
    Spectral10,
    #[serde(rename = "spectral-11")]
    Spectral11,
    #[serde(rename = "spectral-3")]
    Spectral3,
    #[serde(rename = "spectral-4")]
    Spectral4,
    #[serde(rename = "spectral-5")]
    Spectral5,
    #[serde(rename = "spectral-6")]
    Spectral6,
    #[serde(rename = "spectral-7")]
    Spectral7,
    #[serde(rename = "spectral-8")]
    Spectral8,
    #[serde(rename = "spectral-9")]
    Spectral9,
    Tableau10,
    Tableau20,
    Tealblues,
    Teals,
    Turbo,
    Viridis,
    Warmgreys,
    Yellowgreen,
    #[serde(rename = "yellowgreen-3")]
    Yellowgreen3,
    #[serde(rename = "yellowgreen-4")]
    Yellowgreen4,
    #[serde(rename = "yellowgreen-5")]
    Yellowgreen5,
    #[serde(rename = "yellowgreen-6")]
    Yellowgreen6,
    #[serde(rename = "yellowgreen-7")]
    Yellowgreen7,
    #[serde(rename = "yellowgreen-8")]
    Yellowgreen8,
    #[serde(rename = "yellowgreen-9")]
    Yellowgreen9,
    Yellowgreenblue,
    #[serde(rename = "yellowgreenblue-3")]
    Yellowgreenblue3,
    #[serde(rename = "yellowgreenblue-4")]
    Yellowgreenblue4,
    #[serde(rename = "yellowgreenblue-5")]
    Yellowgreenblue5,
    #[serde(rename = "yellowgreenblue-6")]
    Yellowgreenblue6,
    #[serde(rename = "yellowgreenblue-7")]
    Yellowgreenblue7,
    #[serde(rename = "yellowgreenblue-8")]
    Yellowgreenblue8,
    #[serde(rename = "yellowgreenblue-9")]
    Yellowgreenblue9,
    Yelloworangebrown,
    #[serde(rename = "yelloworangebrown-3")]
    Yelloworangebrown3,
    #[serde(rename = "yelloworangebrown-4")]
    Yelloworangebrown4,
    #[serde(rename = "yelloworangebrown-5")]
    Yelloworangebrown5,
    #[serde(rename = "yelloworangebrown-6")]
    Yelloworangebrown6,
    #[serde(rename = "yelloworangebrown-7")]
    Yelloworangebrown7,
    #[serde(rename = "yelloworangebrown-8")]
    Yelloworangebrown8,
    #[serde(rename = "yelloworangebrown-9")]
    Yelloworangebrown9,
    Yelloworangered,
    #[serde(rename = "yelloworangered-3")]
    Yelloworangered3,
    #[serde(rename = "yelloworangered-4")]
    Yelloworangered4,
    #[serde(rename = "yelloworangered-5")]
    Yelloworangered5,
    #[serde(rename = "yelloworangered-6")]
    Yelloworangered6,
    #[serde(rename = "yelloworangered-7")]
    Yelloworangered7,
    #[serde(rename = "yelloworangered-8")]
    Yelloworangered8,
    #[serde(rename = "yelloworangered-9")]
    Yelloworangered9,
}

/// Sort order for the encoded field.
///
/// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
/// `"descending"`.
///
/// For discrete fields, `sort` can be one of the following:
/// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
/// JavaScript.
/// - [A string indicating an encoding channel name to sort
/// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
/// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
/// x-field, descending). This channel string is short-form of [a sort-by-encoding
/// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
/// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
/// "descending"}`.
/// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
/// for sorting by another field.
/// - [An array specifying the field values in preferred
/// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
/// sort order will obey the values in the array, followed by any unspecified values in their
/// original order. For discrete time field, values in the sort array can be [date-time
/// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
/// the values can be the month or day names (case insensitive) or their 3-letter initials
/// (e.g., `"Mon"`, `"Tue"`).
/// - `null` indicating no sort.
///
/// __Default value:__ `"ascending"`
///
/// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
///
/// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum SortUnion {
    EncodingSortField(EncodingSortField),
    Enum(Sort),
    UnionArray(Vec<UnionWith>),
}

/// A sort definition for sorting a discrete scale in an encoding field definition.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct EncodingSortField {
    /// The data [field](https://vega.github.io/vega-lite/docs/field.html) to sort by.
    ///
    /// __Default value:__ If unspecified, defaults to the field specified in the outer data
    /// reference.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub field: RemovableValue<Field>,
    /// An [aggregate operation](https://vega.github.io/vega-lite/docs/aggregate.html#ops) to
    /// perform on the field prior to sorting (e.g., `"count"`, `"mean"` and `"median"`). An
    /// aggregation is required when there are multiple values of the sort field for each encoded
    /// data field. The input data objects will be aggregated, grouped by the encoded data
    /// field.
    ///
    /// For a full list of operations, please see the documentation for
    /// [aggregate](https://vega.github.io/vega-lite/docs/aggregate.html#ops).
    ///
    /// __Default value:__ `"sum"` for stacked plots. Otherwise, `"min"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub op: Option<NonArgAggregateOp>,
    /// The sort order. One of `"ascending"` (default), `"descending"`, or `null` (no not sort).
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub order: RemovableValue<SortOrder>,
    /// The [encoding channel](https://vega.github.io/vega-lite/docs/encoding.html#channels) to
    /// sort by (e.g., `"x"`, `"y"`)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<SortByChannel>,
}

/// The [encoding channel](https://vega.github.io/vega-lite/docs/encoding.html#channels) to
/// sort by (e.g., `"x"`, `"y"`)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SortByChannel {
    Color,
    Fill,
    #[serde(rename = "fillOpacity")]
    FillOpacity,
    Opacity,
    Shape,
    Size,
    Stroke,
    #[serde(rename = "strokeOpacity")]
    StrokeOpacity,
    #[serde(rename = "strokeWidth")]
    StrokeWidth,
    Text,
    X,
    Y,
}

/// The sort order. One of `"ascending"` (default) or `"descending"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SortOrder {
    Ascending,
    Descending,
}

/// The sort order. One of `"ascending"` (default) or `"descending"`.
///
/// The [encoding channel](https://vega.github.io/vega-lite/docs/encoding.html#channels) to
/// sort by (e.g., `"x"`, `"y"`)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Sort {
    Ascending,
    Color,
    Descending,
    Fill,
    #[serde(rename = "fillOpacity")]
    FillOpacity,
    Opacity,
    Shape,
    Size,
    #[serde(rename = "-color")]
    SortColor,
    #[serde(rename = "-fill")]
    SortFill,
    #[serde(rename = "-fillOpacity")]
    SortFillOpacity,
    #[serde(rename = "-opacity")]
    SortOpacity,
    #[serde(rename = "-shape")]
    SortShape,
    #[serde(rename = "-size")]
    SortSize,
    #[serde(rename = "-stroke")]
    SortStroke,
    #[serde(rename = "-strokeOpacity")]
    SortStrokeOpacity,
    #[serde(rename = "-strokeWidth")]
    SortStrokeWidth,
    #[serde(rename = "-text")]
    SortText,
    #[serde(rename = "-x")]
    SortX,
    #[serde(rename = "-y")]
    SortY,
    Stroke,
    #[serde(rename = "strokeOpacity")]
    StrokeOpacity,
    #[serde(rename = "strokeWidth")]
    StrokeWidth,
    Text,
    X,
    Y,
}

/// Color of the marks – either fill or stroke color based on  the `filled` property of mark
/// definition. By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
/// `"text"`, `"trail"`, `"circle"`, and `"square"` / stroke color for `"line"` and
/// `"point"`.
///
/// __Default value:__ If undefined, the default color depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ 1) For fine-grained control over both fill and stroke colors of the marks, please
/// use the `fill` and `stroke` channels. The `fill` or `stroke` encodings have higher
/// precedence than `color`, thus may override the `color` encoding if conflicting encodings
/// are specified. 2) See the scale documentation for more information about customizing
/// [color scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme).
///
/// Fill color of the marks. __Default value:__ If undefined, the default color depends on
/// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ The `fill` encoding has higher precedence than `color`, thus may override the
/// `color` encoding if conflicting encodings are specified.
///
/// Stroke color of the marks. __Default value:__ If undefined, the default color depends on
/// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ The `stroke` encoding has higher precedence than `color`, thus may override the
/// `color` encoding if conflicting encodings are specified.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ColorClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ColorCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_gradient_string_null_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefGradientStringNullExprRefValue>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ColorCondition {
    ConditionalPValueDefGradientStringNullExprRef(ConditionalPValueDefGradientStringNullExprRef),
    ConditionalValueDefGradientStringNullExprRefArray(
        Vec<ConditionalValueDefGradientStringNullExprRef>,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalValueDefGradientStringNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefGradientStringNullExprRefValue>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalValueDefGradientStringNullExprRefValue {
    String(String),
    ValueLinearGradient(ValueLinearGradient),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ValueLinearGradient {
    /// The type of gradient. Use `"linear"` for a linear gradient.
    ///
    /// The type of gradient. Use `"radial"` for a radial gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient: Option<Gradient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<String>,
    /// An array of gradient stops defining the gradient color sequence.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stops: Option<Vec<GradientStop>>,
    /// The starting x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x1: Option<f64>,
    /// The ending x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `1`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<f64>,
    /// The starting y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y1: Option<f64>,
    /// The ending y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the inner circle for the
    /// gradient.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r1: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the outer circle for the
    /// gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r2: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// The type of gradient. Use `"linear"` for a linear gradient.
///
/// The type of gradient. Use `"radial"` for a radial gradient.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Gradient {
    Linear,
    Radial,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GradientStop {
    /// The color value at this point in the gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<String>,
    /// The offset fraction for the color stop, indicating its position within the gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPValueDefGradientStringNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefGradientStringNullExprRefValue>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_value_def_gradient_string_null_expr_ref_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// A field definition for the horizontal facet of trellis plots.
///
/// A field definition for the vertical facet of trellis plots.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RowColumnEncodingFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// The alignment to apply to row/column facet's subplot. The supported string values are
    /// `"all"`, `"each"`, and `"none"`.
    ///
    /// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
    /// one after the other.
    /// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
    /// column may be of variable size.
    /// - For `"all"`, subviews will be aligned and each row or column will be sized identically
    /// based on the maximum observed size. String values for this property will be applied to
    /// both grid rows and columns.
    ///
    /// __Default value:__ `"all"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<LayoutAlign>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// Boolean flag indicating if facet's subviews should be centered relative to their
    /// respective rows or columns.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<bool>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of a facet's header.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header: Option<Header>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` is not supported for `row` and `column`.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortArray>,
    /// The spacing in pixels between facet's sub-views.
    ///
    /// __Default value__: Depends on `"spacing"` property of [the view composition
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#view-config) (`20` by
    /// default)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<f64>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row_column_encoding_field_def_type: Option<StandardType>,
}

/// Headers of row / column channels for faceted plots.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Header {
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Horizontal text alignment of header labels. One of `"left"`, `"center"`, or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<TitleAlignUnion>,
    /// The anchor position for placing the labels. One of `"start"`, `"middle"`, or `"end"`. For
    /// example, with a label orientation of top these anchor positions map to a left-, center-,
    /// or right-aligned label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_anchor: Option<TitleAnchorEnum>,
    /// The rotation angle of the header labels.
    ///
    /// __Default value:__ `0` for column header, `-90` for row header.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_angle: Option<f64>,
    /// The vertical text baseline for the header labels. One of `"alphabetic"` (default),
    /// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
    /// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
    /// relative to the `titleLineHeight` rather than `titleFontSize` alone.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<TextBaseline>,
    /// The color of the header label, can be in hex color code or regular color name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<Box<Color>>,
    /// [Vega expression](https://vega.github.io/vega/docs/expressions/) for customizing labels.
    ///
    /// __Note:__ The label text and value can be assessed via the `label` and `value` properties
    /// of the header's backing `datum` object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_expr: Option<String>,
    /// The font of the header label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<Box<Color>>,
    /// The font size of the header label, in pixels.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<CornerRadiusUnion>,
    /// The font style of the header label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<Box<Color>>,
    /// The font weight of the header label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeightUnion>,
    /// The maximum length of the header label in pixels. The text value will be automatically
    /// truncated if the rendered size exceeds the limit.
    ///
    /// __Default value:__ `0`, indicating no limit
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    /// Line height in pixels for multi-line header labels or title text with `"line-top"` or
    /// `"line-bottom"` baseline.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_line_height: Option<CornerRadiusUnion>,
    /// The orientation of the header label. One of `"top"`, `"bottom"`, `"left"` or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_orient: Option<Orient>,
    /// The padding, in pixel, between facet header's label and the plot.
    ///
    /// __Default value:__ `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<CornerRadiusUnion>,
    /// A boolean flag indicating if labels should be included as part of the header.
    ///
    /// __Default value:__ `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<bool>,
    /// Shortcut for setting both labelOrient and titleOrient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orient>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// Horizontal text alignment (to the anchor) of header titles.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    /// The anchor position for placing the title. One of `"start"`, `"middle"`, or `"end"`. For
    /// example, with an orientation of top these anchor positions map to a left-, center-, or
    /// right-aligned title.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorEnum>,
    /// The rotation angle of the header title.
    ///
    /// __Default value:__ `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_angle: Option<f64>,
    /// The vertical text baseline for the header title. One of `"alphabetic"` (default),
    /// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
    /// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
    /// relative to the `titleLineHeight` rather than `titleFontSize` alone.
    ///
    /// __Default value:__ `"middle"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    /// Color of the header title, can be in hex color code or regular color name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    /// Font of the header title. (e.g., `"Helvetica Neue"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    /// Font size of the header title.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<CornerRadiusUnion>,
    /// The font style of the header title.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    /// Font weight of the header title. This can be either a string (e.g `"bold"`, `"normal"`)
    /// or a number (`100`, `200`, `300`, ..., `900` where `"normal"` = `400` and `"bold"` =
    /// `700`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    /// The maximum length of the header title in pixels. The text value will be automatically
    /// truncated if the rendered size exceeds the limit.
    ///
    /// __Default value:__ `0`, indicating no limit
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<CornerRadiusUnion>,
    /// Line height in pixels for multi-line header title text or title text with `"line-top"` or
    /// `"line-bottom"` baseline.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    /// The orientation of the header title. One of `"top"`, `"bottom"`, `"left"` or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_orient: Option<Orient>,
    /// The padding, in pixel, between facet header's title and the label.
    ///
    /// __Default value:__ `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
}

/// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
/// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
/// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
///
/// Vega-Lite automatically infers data types in many cases as discussed below. However, type
/// is required for a field if: (1) the field is not nominal and the field encoding has no
/// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
/// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
/// or `timeUnit`.
///
/// __Default value:__
///
/// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
/// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
/// following criteria:
/// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
/// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
/// `longitude` channel or (3) if the specified scale type is [a quantitative
/// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
/// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
/// the specified scale type is a time or utc scale
/// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
/// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
/// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
/// `order`.
///
/// 2) For a constant value in data domain (`datum`):
/// - `"quantitative"` if the datum is a number
/// - `"nominal"` if the datum is a string
/// - `"temporal"` if the datum is [a date time
/// object](https://vega.github.io/vega-lite/docs/datetime.html)
///
/// __Note:__
/// - Data `type` describes the semantics of the data rather than the primitive data types
/// (number, string, etc.). The same primitive data type can have different types of
/// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
/// data.
/// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
/// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
/// `1552199579097`).
/// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
/// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
/// (for using an ordinal bin
/// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
/// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
/// `type` property can be either `"temporal"` (default, for using a temporal scale) or
/// [`"ordinal"` (for using an ordinal
/// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
/// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
/// the `type` property refers to the post-aggregation data type. For example, we can
/// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
/// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
/// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
/// must have exactly the same type as their primary channels (e.g., `x`, `y`).
///
/// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StandardType {
    Nominal,
    Ordinal,
    Quantitative,
    Temporal,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum SortArray {
    Enum(SortOrder),
    SortEncodingSortField(SortEncodingSortField),
    UnionArray(Vec<UnionWith>),
}

/// A sort definition for sorting a discrete scale in an encoding field definition.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SortEncodingSortField {
    /// The data [field](https://vega.github.io/vega-lite/docs/field.html) to sort by.
    ///
    /// __Default value:__ If unspecified, defaults to the field specified in the outer data
    /// reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An [aggregate operation](https://vega.github.io/vega-lite/docs/aggregate.html#ops) to
    /// perform on the field prior to sorting (e.g., `"count"`, `"mean"` and `"median"`). An
    /// aggregation is required when there are multiple values of the sort field for each encoded
    /// data field. The input data objects will be aggregated, grouped by the encoded data
    /// field.
    ///
    /// For a full list of operations, please see the documentation for
    /// [aggregate](https://vega.github.io/vega-lite/docs/aggregate.html#ops).
    ///
    /// __Default value:__ `"sum"` for stacked plots. Otherwise, `"min"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub op: Option<NonArgAggregateOp>,
    /// The sort order. One of `"ascending"` (default), `"descending"`, or `null` (no not sort).
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub order: RemovableValue<SortOrder>,
}

/// A text description of this mark for ARIA accessibility (SVG output only). For SVG output
/// the `"aria-label"` attribute will be set to this description.
///
/// A URL to load upon mouse click.
///
/// The URL of an image mark.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DescriptionClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<DescriptionCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field_or_datum_def_with_condition_string_field_def_string_type: Option<StandardType>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DescriptionBin {
    BinParams(BinParams),
    Bool(bool),
    Enum(BinEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BinEnum {
    Binned,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DescriptionCondition {
    PurpleConditionalPExprRef(PurpleConditionalPExprRef),
    PurpleConditionalValueDefStringExprRefArray(Vec<PurpleConditionalValueDefStringExprRef>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleConditionalValueDefStringExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleConditionalPExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_expr_ref_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Detail {
    TypedFieldDef(TypedFieldDef),
    TypedFieldDefArray(Vec<TypedFieldDef>),
}

/// Field Def without scale (and without bin: "binned" support).
///
/// Definition object for a data field, its type and transformation of an encoding channel.
///
/// A data field to use as a unique key for data binding. When a visualization’s data is
/// updated, the key value will be used to match data elements to existing mark instances.
/// Use a key channel to enable object constancy for transitions over dynamic data.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TypedFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub typed_field_def_type: Option<StandardType>,
}

/// A field definition for the (flexible) facet of trellis plots.
///
/// If either `row` or `column` is specified, this channel will be ignored.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FacetEncodingFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// The alignment to apply to grid rows and columns. The supported string values are `"all"`,
    /// `"each"`, and `"none"`.
    ///
    /// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
    /// one after the other.
    /// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
    /// column may be of variable size.
    /// - For `"all"`, subviews will be aligned and each row or column will be sized identically
    /// based on the maximum observed size. String values for this property will be applied to
    /// both grid rows and columns.
    ///
    /// Alternatively, an object value of the form `{"row": string, "column": string}` can be
    /// used to supply different alignments for rows and columns.
    ///
    /// __Default value:__ `"all"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Box<VegaliteAlign>>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// The bounds calculation method to use for determining the extent of a sub-plot. One of
    /// `full` (the default) or `flush`.
    ///
    /// - If set to `full`, the entire calculated bounds (including axes, title, and legend) will
    /// be used.
    /// - If set to `flush`, only the specified width and height values for the sub-view will be
    /// used. The `flush` setting can be useful when attempting to place sub-plots without axes
    /// or legends into a uniform grid structure.
    ///
    /// __Default value:__ `"full"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bounds: Option<Box<Bounds>>,
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// An object value of the form `{"row": boolean, "column": boolean}` can be used to supply
    /// different centering values for rows and columns.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<Box<Center>>,
    /// The number of columns to include in the view composition layout.
    ///
    /// __Default value__: `undefined` -- An infinite number of columns (a single row) will be
    /// assumed. This is equivalent to `hconcat` (for `concat`) and to using the `column` channel
    /// (for `facet` and `repeat`).
    ///
    /// __Note__:
    ///
    /// 1) This property is only for:
    /// - the general (wrappable) `concat` operator (not `hconcat`/`vconcat`)
    /// - the `facet` and `repeat` operator with one field/repetition definition (without
    /// row/column nesting)
    ///
    /// 2) Setting the `columns` to `1` is equivalent to `vconcat` (for `concat`) and to using
    /// the `row` channel (for `facet` and `repeat`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<f64>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of a facet's header.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header: Option<Header>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` is not supported for `row` and `column`.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortArray>,
    /// The spacing in pixels between sub-views of the composition operator. An object of the
    /// form `{"row": number, "column": number}` can be used to set different spacing values for
    /// rows and columns.
    ///
    /// __Default value__: Depends on `"spacing"` property of [the view composition
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#view-config) (`20` by
    /// default)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<Box<Spacing>>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet_encoding_field_def_type: Option<StandardType>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Spacing {
    Double(f64),
    RowColNumber(RowColNumber),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RowColNumber {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<f64>,
}

/// Color of the marks – either fill or stroke color based on  the `filled` property of mark
/// definition. By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
/// `"text"`, `"trail"`, `"circle"`, and `"square"` / stroke color for `"line"` and
/// `"point"`.
///
/// __Default value:__ If undefined, the default color depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ 1) For fine-grained control over both fill and stroke colors of the marks, please
/// use the `fill` and `stroke` channels. The `fill` or `stroke` encodings have higher
/// precedence than `color`, thus may override the `color` encoding if conflicting encodings
/// are specified. 2) See the scale documentation for more information about customizing
/// [color scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme).
///
/// Fill color of the marks. __Default value:__ If undefined, the default color depends on
/// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ The `fill` encoding has higher precedence than `color`, thus may override the
/// `color` encoding if conflicting encodings are specified.
///
/// Stroke color of the marks. __Default value:__ If undefined, the default color depends on
/// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ The `stroke` encoding has higher precedence than `color`, thus may override the
/// `color` encoding if conflicting encodings are specified.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FillClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ColorCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_gradient_string_null_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefGradientStringNullExprRefValue>,
}

/// Rotation angle of point and text marks.
///
/// Fill opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
/// property.
///
/// Opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
/// property.
///
/// Size of the mark.
/// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
/// - For `"bar"` and `"tick"` – the bar and tick's size.
/// - For `"text"` – the text's font size.
/// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
/// line with varying size)
///
/// Stroke opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
/// property.
///
/// Stroke width of the marks.
///
/// __Default value:__ If undefined, the default stroke width depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
/// property.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FillOpacityClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<AngleCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

/// A text description of this mark for ARIA accessibility (SVG output only). For SVG output
/// the `"aria-label"` attribute will be set to this description.
///
/// A URL to load upon mouse click.
///
/// The URL of an image mark.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct HrefClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<DescriptionCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field_or_datum_def_with_condition_string_field_def_string_type: Option<StandardType>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
}

/// Field Def without scale (and without bin: "binned" support).
///
/// Definition object for a data field, its type and transformation of an encoding channel.
///
/// A data field to use as a unique key for data binding. When a visualization’s data is
/// updated, the key value will be used to match data elements to existing mark instances.
/// Use a key channel to enable object constancy for transitions over dynamic data.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct KeyClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub typed_field_def_type: Option<StandardType>,
}

/// Latitude position of geographically projected marks.
///
/// Longitude position of geographically projected marks.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LatitudeClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub lat_long_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
/// `"rule"`.
///
/// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
/// and  `"rule"`.
///
/// The inner radius in pixels of arc marks.
///
/// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
/// values proceed clockwise.
///
/// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Latitude2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position2_def_type: Option<Type>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Latitude2Value {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
    Enum(ValueEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ValueEnum {
    Height,
    Width,
}

/// Latitude position of geographically projected marks.
///
/// Longitude position of geographically projected marks.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LongitudeClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub lat_long_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
/// `"rule"`.
///
/// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
/// and  `"rule"`.
///
/// The inner radius in pixels of arc marks.
///
/// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
/// values proceed clockwise.
///
/// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Longitude2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position2_def_type: Option<Type>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

/// Rotation angle of point and text marks.
///
/// Fill opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
/// property.
///
/// Opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
/// property.
///
/// Size of the mark.
/// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
/// - For `"bar"` and `"tick"` – the bar and tick's size.
/// - For `"text"` – the text's font size.
/// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
/// line with varying size)
///
/// Stroke opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
/// property.
///
/// Stroke width of the marks.
///
/// __Default value:__ If undefined, the default stroke width depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
/// property.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct OpacityClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<AngleCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Order {
    OrderDef(OrderDef),
    OrderFieldDefArray(Vec<OrderFieldDef>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct OrderFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// The sort order. One of `"ascending"` (default) or `"descending"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sort: Option<SortOrder>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order_field_def_type: Option<StandardType>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct OrderDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// The sort order. One of `"ascending"` (default) or `"descending"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sort: Option<SortOrder>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order_def_type: Option<StandardType>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<OrderFieldDefCondition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

/// One or more value definition(s) with [a parameter or a test
/// predicate](https://vega.github.io/vega-lite/docs/condition.html).
///
/// __Note:__ A field definition's `condition` property can only contain [conditional value
/// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
/// only allows at most one encoded field per encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum OrderFieldDefCondition {
    ConditionalPValueDefNumber(ConditionalPValueDefNumber),
    ConditionalValueDefNumberArray(Vec<ConditionalValueDefNumber>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalValueDefNumber {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPValueDefNumber {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

/// The outer radius in pixels of arc marks.
///
/// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
/// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
/// clockwise.)
///
/// - For text marks, polar coordinate angle in radians.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RadiusClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Type of stacking offset if the field should be stacked. `stack` is only applicable for
    /// `x`, `y`, `theta`, and `radius` channels with continuous domains. For example, `stack` of
    /// `y` can be used to customize stacking for a vertical bar chart.
    ///
    /// `stack` can be one of the following values:
    /// - `"zero"` or `true`: stacking with baseline offset at zero value of the scale (for
    /// creating typical stacked [bar](https://vega.github.io/vega-lite/docs/stack.html#bar) and
    /// [area](https://vega.github.io/vega-lite/docs/stack.html#area) chart).
    /// - `"normalize"` - stacking with normalized domain (for creating [normalized stacked bar
    /// and area charts](https://vega.github.io/vega-lite/docs/stack.html#normalized) and pie
    /// charts [with percentage
    /// tooltip](https://vega.github.io/vega-lite/docs/arc.html#tooltip)). <br/>
    /// -`"center"` - stacking with center baseline (for
    /// [streamgraph](https://vega.github.io/vega-lite/docs/stack.html#streamgraph)).
    /// - `null` or `false` - No-stacking. This will produce layered
    /// [bar](https://vega.github.io/vega-lite/docs/stack.html#layered-bar-chart) and area
    /// chart.
    ///
    /// __Default value:__ `zero` for plots with all of the following conditions are true: (1)
    /// the mark is `bar`, `area`, or `arc`; (2) the stacked measure channel (x or y) has a
    /// linear scale; (3) At least one of non-position channels mapped to an unaggregated field
    /// that is different from x and y. Otherwise, `null` by default.
    ///
    /// __See also:__ [`stack`](https://vega.github.io/vega-lite/docs/stack.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stack: Option<Stack>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub polar_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Stack {
    Bool(bool),
    Enum(StackOffset),
}

/// Mode for stacking marks. One of `"zero"` (default), `"center"`, or `"normalize"`. The
/// `"zero"` offset will stack starting at `0`. The `"center"` offset will center the stacks.
/// The `"normalize"` offset will compute percentage values for each stack point, with output
/// values in the range `[0,1]`.
///
/// __Default value:__ `"zero"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StackOffset {
    Center,
    Normalize,
    Zero,
}

/// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
/// `"rule"`.
///
/// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
/// and  `"rule"`.
///
/// The inner radius in pixels of arc marks.
///
/// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
/// values proceed clockwise.
///
/// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Radius2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position2_def_type: Option<Type>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

/// Shape of the mark.
///
/// 1. For `point` marks the supported values include:   - plotting shapes: `"circle"`,
/// `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`, `"triangle-down"`,
/// `"triangle-right"`, or `"triangle-left"`.   - the line symbol `"stroke"`   - centered
/// directional shapes `"arrow"`, `"wedge"`, or `"triangle"`   - a custom [SVG path
/// string](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths) (For correct
/// sizing, custom shape paths should be defined within a square bounding box with
/// coordinates ranging from -1 to 1 along both the x and y dimensions.)
///
/// 2. For `geoshape` marks it should be a field definition of the geojson data
///
/// __Default value:__ If undefined, the default shape depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#point-config)'s `shape`
/// property. (`"circle"` if unset.)
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct MarkPropDefStringNullTypeForShape {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ShapeCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_string_null_type_for_shape_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ShapeCondition {
    ConditionalPValueDefStringNullExprRef(ConditionalPValueDefStringNullExprRef),
    ConditionalValueDefStringNullExprRefArray(Vec<ConditionalValueDefStringNullExprRef>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalValueDefStringNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPValueDefStringNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_value_def_string_null_expr_ref_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// Rotation angle of point and text marks.
///
/// Fill opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
/// property.
///
/// Opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
/// property.
///
/// Size of the mark.
/// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
/// - For `"bar"` and `"tick"` – the bar and tick's size.
/// - For `"text"` – the text's font size.
/// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
/// line with varying size)
///
/// Stroke opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
/// property.
///
/// Stroke width of the marks.
///
/// __Default value:__ If undefined, the default stroke width depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
/// property.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SizeClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<AngleCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

/// Color of the marks – either fill or stroke color based on  the `filled` property of mark
/// definition. By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
/// `"text"`, `"trail"`, `"circle"`, and `"square"` / stroke color for `"line"` and
/// `"point"`.
///
/// __Default value:__ If undefined, the default color depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ 1) For fine-grained control over both fill and stroke colors of the marks, please
/// use the `fill` and `stroke` channels. The `fill` or `stroke` encodings have higher
/// precedence than `color`, thus may override the `color` encoding if conflicting encodings
/// are specified. 2) See the scale documentation for more information about customizing
/// [color scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme).
///
/// Fill color of the marks. __Default value:__ If undefined, the default color depends on
/// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ The `fill` encoding has higher precedence than `color`, thus may override the
/// `color` encoding if conflicting encodings are specified.
///
/// Stroke color of the marks. __Default value:__ If undefined, the default color depends on
/// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
/// property.
///
/// _Note:_ The `stroke` encoding has higher precedence than `color`, thus may override the
/// `color` encoding if conflicting encodings are specified.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct StrokeClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ColorCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_gradient_string_null_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefGradientStringNullExprRefValue>,
}

/// Stroke dash of the marks.
///
/// __Default value:__ `[1,0]` (No dash).
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct MarkPropDefNumber {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<StrokeDashCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<StrokeDashUnion>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum StrokeDashCondition {
    ConditionalParameterValueDefNumberExprRefClass(ConditionalParameterValueDefNumberExprRefClass),
    ConditionalValueDefNumberExprRefElementArray(Vec<ConditionalValueDefNumberExprRefElement>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalValueDefNumberExprRefElement {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefNumberExprRefValueUnion>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

/// The projection’s translation offset as a two-element array `[tx, ty]`.
///
/// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
/// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
/// between `0` to `1` for opacity).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalValueDefNumberExprRefValueUnion {
    BackgroundExprRef(BackgroundExprRef),
    DoubleArray(Vec<f64>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalParameterValueDefNumberExprRefClass {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<StrokeDashUnion>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_value_def_number_expr_ref_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// Rotation angle of point and text marks.
///
/// Fill opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
/// property.
///
/// Opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
/// property.
///
/// Size of the mark.
/// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
/// - For `"bar"` and `"tick"` – the bar and tick's size.
/// - For `"text"` – the text's font size.
/// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
/// line with varying size)
///
/// Stroke opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
/// property.
///
/// Stroke width of the marks.
///
/// __Default value:__ If undefined, the default stroke width depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
/// property.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct StrokeOpacityClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<AngleCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

/// Rotation angle of point and text marks.
///
/// Fill opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
/// property.
///
/// Opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
/// property.
///
/// Size of the mark.
/// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
/// - For `"bar"` and `"tick"` – the bar and tick's size.
/// - For `"text"` – the text's font size.
/// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
/// line with varying size)
///
/// Stroke opacity of the marks.
///
/// __Default value:__ If undefined, the default opacity depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
/// property.
///
/// Stroke width of the marks.
///
/// __Default value:__ If undefined, the default stroke width depends on [mark
/// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
/// property.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct StrokeWidthClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<AngleCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark_prop_def_number_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<CornerRadiusUnion>,
}

/// Text of the `text` mark.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TextDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<TextCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalPredicateValueDefTextExprRefText>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TextCondition {
    ConditionalP(ConditionalP),
    ConditionalValueDefTextExprRefArray(Vec<ConditionalValueDefTextExprRef>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalValueDefTextExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalValueDefTextExprRefText>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

/// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
/// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
/// between `0` to `1` for opacity).
///
/// The title text.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalValueDefTextExprRefText {
    BackgroundExprRef(BackgroundExprRef),
    String(String),
    StringArray(Vec<String>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalP {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_type: Option<StandardType>,
}

/// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
/// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
/// between `0` to `1` for opacity).
///
/// The title text.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalPredicateValueDefTextExprRefText {
    BackgroundExprRef(BackgroundExprRef),
    String(String),
    StringArray(Vec<String>),
}

/// The outer radius in pixels of arc marks.
///
/// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
/// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
/// clockwise.)
///
/// - For text marks, polar coordinate angle in radians.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ThetaClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Type of stacking offset if the field should be stacked. `stack` is only applicable for
    /// `x`, `y`, `theta`, and `radius` channels with continuous domains. For example, `stack` of
    /// `y` can be used to customize stacking for a vertical bar chart.
    ///
    /// `stack` can be one of the following values:
    /// - `"zero"` or `true`: stacking with baseline offset at zero value of the scale (for
    /// creating typical stacked [bar](https://vega.github.io/vega-lite/docs/stack.html#bar) and
    /// [area](https://vega.github.io/vega-lite/docs/stack.html#area) chart).
    /// - `"normalize"` - stacking with normalized domain (for creating [normalized stacked bar
    /// and area charts](https://vega.github.io/vega-lite/docs/stack.html#normalized) and pie
    /// charts [with percentage
    /// tooltip](https://vega.github.io/vega-lite/docs/arc.html#tooltip)). <br/>
    /// -`"center"` - stacking with center baseline (for
    /// [streamgraph](https://vega.github.io/vega-lite/docs/stack.html#streamgraph)).
    /// - `null` or `false` - No-stacking. This will produce layered
    /// [bar](https://vega.github.io/vega-lite/docs/stack.html#layered-bar-chart) and area
    /// chart.
    ///
    /// __Default value:__ `zero` for plots with all of the following conditions are true: (1)
    /// the mark is `bar`, `area`, or `arc`; (2) the stacked measure channel (x or y) has a
    /// linear scale; (3) At least one of non-position channels mapped to an unaggregated field
    /// that is different from x and y. Otherwise, `null` by default.
    ///
    /// __See also:__ [`stack`](https://vega.github.io/vega-lite/docs/stack.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stack: Option<Stack>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub polar_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

/// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
/// `"rule"`.
///
/// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
/// and  `"rule"`.
///
/// The inner radius in pixels of arc marks.
///
/// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
/// values proceed clockwise.
///
/// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Theta2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position2_def_type: Option<Type>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TimeFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rescale: Option<bool>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_field_def_type: Option<StandardType>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum EncodingTooltip {
    FieldOrDatumDefWithConditionStringFieldDefString(
        FieldOrDatumDefWithConditionStringFieldDefString,
    ),
    StringFieldDefArray(Vec<StringFieldDef>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct StringFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub string_field_def_type: Option<StandardType>,
}

/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FieldOrDatumDefWithConditionStringFieldDefString {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<FieldOrDatumDefWithConditionStringFieldDefStringCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field_or_datum_def_with_condition_string_field_def_string_type: Option<StandardType>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FieldOrDatumDefWithConditionStringFieldDefStringCondition {
    FluffyConditionalPExprRef(FluffyConditionalPExprRef),
    FluffyConditionalValueDefStringExprRefArray(Vec<FluffyConditionalValueDefStringExprRef>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FluffyConditionalValueDefStringExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FluffyConditionalPExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
    /// For selection parameters, the predicate of empty selections returns true by default.
    /// Override this behavior, by setting this property `empty: false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub empty: Option<bool>,
    /// Filter using a parameter name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the legend. If `null`, the legend for the encoding
    /// channel will be removed.
    ///
    /// __Default value:__ If undefined, default [legend
    /// properties](https://vega.github.io/vega-lite/docs/legend.html) are applied.
    ///
    /// __See also:__ [`legend`](https://vega.github.io/vega-lite/docs/legend.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub legend: RemovableValue<Legend>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub conditional_p_expr_ref_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
}

/// A text description of this mark for ARIA accessibility (SVG output only). For SVG output
/// the `"aria-label"` attribute will be set to this description.
///
/// A URL to load upon mouse click.
///
/// The URL of an image mark.
///
/// A FieldDef with Condition<ValueDef> {   condition: {value: ...},   field: ...,   ... }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct UrlClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// One or more value definition(s) with [a parameter or a test
    /// predicate](https://vega.github.io/vega-lite/docs/condition.html).
    ///
    /// __Note:__ A field definition's `condition` property can only contain [conditional value
    /// definitions](https://vega.github.io/vega-lite/docs/condition.html#value) since Vega-Lite
    /// only allows at most one encoded field per encoding channel.
    ///
    /// A field definition or one or more value definition(s) with a parameter predicate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<DescriptionCondition>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field_or_datum_def_with_condition_string_field_def_string_type: Option<StandardType>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Box<Color>>,
}

/// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
/// `x2` or `width`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
/// `y2` or `height`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct XClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// An object defining properties of axis's gridlines, ticks and labels. If `null`, the axis
    /// for the encoding channel will be removed.
    ///
    /// __Default value:__ If undefined, default [axis
    /// properties](https://vega.github.io/vega-lite/docs/axis.html) are applied.
    ///
    /// __See also:__ [`axis`](https://vega.github.io/vega-lite/docs/axis.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub axis: RemovableValue<Axis>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining the properties of the Impute Operation to be applied. The field value
    /// of the other positional channel is taken as `key` of the `Impute` Operation. The field of
    /// the `color` channel if specified is used as `groupby` of the `Impute` Operation.
    ///
    /// __See also:__ [`impute`](https://vega.github.io/vega-lite/docs/impute.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub impute: Option<ImputeParams>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Type of stacking offset if the field should be stacked. `stack` is only applicable for
    /// `x`, `y`, `theta`, and `radius` channels with continuous domains. For example, `stack` of
    /// `y` can be used to customize stacking for a vertical bar chart.
    ///
    /// `stack` can be one of the following values:
    /// - `"zero"` or `true`: stacking with baseline offset at zero value of the scale (for
    /// creating typical stacked [bar](https://vega.github.io/vega-lite/docs/stack.html#bar) and
    /// [area](https://vega.github.io/vega-lite/docs/stack.html#area) chart).
    /// - `"normalize"` - stacking with normalized domain (for creating [normalized stacked bar
    /// and area charts](https://vega.github.io/vega-lite/docs/stack.html#normalized) and pie
    /// charts [with percentage
    /// tooltip](https://vega.github.io/vega-lite/docs/arc.html#tooltip)). <br/>
    /// -`"center"` - stacking with center baseline (for
    /// [streamgraph](https://vega.github.io/vega-lite/docs/stack.html#streamgraph)).
    /// - `null` or `false` - No-stacking. This will produce layered
    /// [bar](https://vega.github.io/vega-lite/docs/stack.html#layered-bar-chart) and area
    /// chart.
    ///
    /// __Default value:__ `zero` for plots with all of the following conditions are true: (1)
    /// the mark is `bar`, `area`, or `arc`; (2) the stacked measure channel (x or y) has a
    /// linear scale; (3) At least one of non-position channels mapped to an unaggregated field
    /// that is different from x and y. Otherwise, `null` by default.
    ///
    /// __See also:__ [`stack`](https://vega.github.io/vega-lite/docs/stack.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stack: Option<Stack>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Axis {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    /// A boolean flag indicating if the domain (the axis baseline) should be included as part of
    /// the axis.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_width: Option<CornerRadiusUnion>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// A boolean flag indicating if grid lines should be included as part of the axis
    ///
    /// __Default value:__ `true` for [continuous
    /// scales](https://vega.github.io/vega-lite/docs/scale.html#continuous) that are not binned;
    /// otherwise, `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_color: Option<GridColorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_dash: Option<AxisGridDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_dash_offset: Option<GridDashOffsetUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_opacity: Option<GridOpacityUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_width: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<ConditionalAxisPropertyAlignNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_angle: Option<LabelAngle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<PurpleTextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_bound: Option<Label>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<GridColorUnion>,
    /// [Vega expression](https://vega.github.io/vega/docs/expressions/) for customizing labels.
    ///
    /// __Note:__ The label text and value can be assessed via the `label` and `value` properties
    /// of the axis's backing `datum` object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_expr: Option<String>,
    /// Indicates if the first and last axis labels should be aligned flush with the scale range.
    /// Flush alignment for a horizontal axis will left-align the first label and right-align the
    /// last label. For vertical axes, bottom and top text baselines are applied instead. If this
    /// property is a number, it also indicates the number of pixels by which to offset the first
    /// and last labels; for example, a value of 2 will flush-align the first and last labels and
    /// also push them 2 pixels outward from the center of the axis. The additional adjustment
    /// can sometimes help the labels better visually group with corresponding axis ticks.
    ///
    /// __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_flush: Option<LabelFlush>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_flush_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<ConditionalAxisPropertyStringNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<ConditionalAxisPropertyFontStyleNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeight>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_offset: Option<GridDashOffsetUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_opacity: Option<GridDashOffsetUnion>,
    /// The strategy to use for resolving overlap of axis labels. If `false` (the default), no
    /// overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
    /// every other label is used (this works well for standard linear axes). If set to
    /// `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
    /// with the last visible label (this often works better for log-scaled axes).
    ///
    /// __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
    /// scales; otherwise `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_overlap: Option<LabelOverlapUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<GridDashOffsetUnion>,
    /// A boolean flag indicating if labels should be included as part of the axis.
    ///
    /// __Default value:__ `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_separation: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_extent: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_extent: Option<CornerRadiusUnion>,
    /// The offset, in pixels, by which to displace the axis from the edge of the enclosing group
    /// or data rectangle.
    ///
    /// __Default value:__ derived from the [axis
    /// config](https://vega.github.io/vega-lite/docs/config.html#facet-scale-config)'s `offset`
    /// (`0` by default)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    /// The orientation of the axis. One of `"top"`, `"bottom"`, `"left"` or `"right"`. The
    /// orientation can be used to further specialize the axis type (e.g., a y-axis oriented
    /// towards the right edge of the chart).
    ///
    /// __Default value:__ `"bottom"` for x-axes and `"left"` for y-axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<TitleOrientUnion>,
    /// The anchor position of the axis in pixels. For x-axes with top or bottom orientation,
    /// this sets the axis group x coordinate. For y-axes with left or right orientation, this
    /// sets the axis group y coordinate.
    ///
    /// __Default value__: `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position: Option<CornerRadiusUnion>,
    /// A string or array of strings indicating the name of custom styles to apply to the axis. A
    /// style is a named collection of axis property defined within the [style
    /// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
    /// an array, later styles will override earlier styles.
    ///
    /// __Default value:__ (none) __Note:__ Any specified style will augment the default style.
    /// For example, an x-axis mark with `"style": "foo"` will use `config.axisX` and
    /// `config.style.foo` (the specified style `"foo"` has higher precedence).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_band: Option<TickBandUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_color: Option<GridColorUnion>,
    /// A desired number of ticks, for axes visualizing quantitative scales. The resulting number
    /// may be different so that values are "nice" (multiples of 2, 5, 10) and lie within the
    /// underlying scale's range.
    ///
    /// For scales of type `"time"` or `"utc"`, the tick count can instead be a time interval
    /// specifier. Legal string values are `"millisecond"`, `"second"`, `"minute"`, `"hour"`,
    /// `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, an object-valued interval
    /// specifier of the form `{"interval": "month", "step": 3}` includes a desired number of
    /// interval steps. Here, ticks are generated for each quarter (Jan, Apr, Jul, Oct)
    /// boundary.
    ///
    /// __Default value__: Determine using a formula `ceil(width/40)` for x and `ceil(height/40)`
    /// for y.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_count: Option<TickCount>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_dash: Option<AxisTickDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_dash_offset: Option<GridDashOffsetUnion>,
    /// Boolean flag indicating if an extra axis tick should be added for the initial position of
    /// the axis. This flag is useful for styling axes for `band` scales such that ticks are
    /// placed on band boundaries rather in the middle of a band. Use in conjunction with
    /// `"bandPosition": 1` and an axis `"padding"` value of `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_extra: Option<bool>,
    /// The minimum desired step between axis ticks, in terms of scale domain values. For
    /// example, a value of `1` indicates that ticks should not be less than 1 unit apart. If
    /// `tickMinStep` is specified, the `tickCount` value will be adjusted, if necessary, to
    /// enforce the minimum step value.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_min_step: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_opacity: Option<GridDashOffsetUnion>,
    /// Boolean flag indicating if pixel position values should be rounded to the nearest
    /// integer.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_round: Option<bool>,
    /// Boolean value that determines whether the axis should include ticks.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ticks: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_size: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_width: Option<GridWidthUnion>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_angle: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_x: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_y: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub translate: Option<CornerRadiusUnion>,
    /// Explicitly set the visible axis tick values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub values: Option<Values>,
    /// A non-negative integer indicating the z-index of the axis. If zindex is 0, axes should be
    /// drawn behind all chart elements. To put them in front, set `zindex` to `1` or more.
    ///
    /// __Default value:__ `0` (behind the marks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Cap {
    BackgroundExprRef(BackgroundExprRef),
    Enum(StrokeCap),
}

/// The stroke cap for line ending style. One of `"butt"`, `"round"`, or `"square"`.
///
/// __Default value:__ `"butt"`
///
/// The stroke cap for the domain line's ending style. One of `"butt"`, `"round"` or
/// `"square"`.
///
/// __Default value:__ `"butt"`
///
/// The stroke cap for grid lines' ending style. One of `"butt"`, `"round"` or `"square"`.
///
/// __Default value:__ `"butt"`
///
/// The stroke cap for the tick lines' ending style. One of `"butt"`, `"round"` or
/// `"square"`.
///
/// __Default value:__ `"butt"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StrokeCap {
    Butt,
    Round,
    Square,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum GridColorUnion {
    GridColorExprRef(GridColorExprRef),
    String(String),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GridColorExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ConditionUnion>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionUnion {
    ConditionClass(ConditionClass),
    ConditionalPredicateValueDefColorNullExprRefArray(
        Vec<ConditionalPredicateValueDefColorNullExprRef>,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefColorNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionClass {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AxisGridDash {
    DoubleArray(Vec<f64>),
    PurpleExprRef(PurpleExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<TentacledConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TentacledConditionalPredicateValueDefNumberNullExprRef {
    ConditionalPredicateValueDefNumberNullExprRefArray(
        Vec<ConditionalPredicateValueDefNumberNullExprRef>,
    ),
    PurpleConditionalPredicateValueDefNumberNullExprRef(
        PurpleConditionalPredicateValueDefNumberNullExprRef,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefNumberNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleConditionalPredicateValueDefNumberNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum GridDashOffsetUnion {
    Double(f64),
    GridDashOffsetExprRef(GridDashOffsetExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GridDashOffsetExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<StickyConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum StickyConditionalPredicateValueDefNumberNullExprRef {
    ConditionalPredicateValueDefNumberNullExprRefElementArray(
        Vec<ConditionalPredicateValueDefNumberNullExprRefElement>,
    ),
    FluffyConditionalPredicateValueDefNumberNullExprRef(
        FluffyConditionalPredicateValueDefNumberNullExprRef,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefNumberNullExprRefElement {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FluffyConditionalPredicateValueDefNumberNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum GridOpacityUnion {
    Double(f64),
    GridOpacityExprRef(GridOpacityExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GridOpacityExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<StickyConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum GridWidthUnion {
    Double(f64),
    GridWidthExprRef(GridWidthExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct GridWidthExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<StickyConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalAxisPropertyAlignNull {
    Enum(Align),
    FluffyExprRef(FluffyExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FluffyExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ExprRefCondition>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Align>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ExprRefCondition {
    ConditionCondition(ConditionCondition),
    ConditionalPredicateValueDefAlignNullExprRefArray(
        Vec<ConditionalPredicateValueDefAlignNullExprRef>,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefAlignNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Align>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionCondition {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Align>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum LabelAngle {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum PurpleTextBaseline {
    Enum(Baseline),
    TentacledExprRef(TentacledExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TentacledExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<ExprRefConditionUnion>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Baseline>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ExprRefConditionUnion {
    ConditionConditionClass(ConditionConditionClass),
    ConditionalPredicateValueDefTextBaselineNullExprRefArray(
        Vec<ConditionalPredicateValueDefTextBaselineNullExprRef>,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefTextBaselineNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Baseline>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionConditionClass {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Baseline>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Label {
    BackgroundExprRef(BackgroundExprRef),
    Bool(bool),
    Double(f64),
}

/// Indicates if labels should be hidden if they exceed the axis range. If `false` (the
/// default) no bounds overlap analysis is performed. If `true`, labels will be hidden if
/// they exceed the axis range by more than 1 pixel. If this property is a number, it
/// specifies the pixel tolerance: the maximum amount by which a label bounding box may
/// exceed the axis range.
///
/// __Default value:__ `false`.
///
/// Indicates if the first and last axis labels should be aligned flush with the scale range.
/// Flush alignment for a horizontal axis will left-align the first label and right-align the
/// last label. For vertical axes, bottom and top text baselines are applied instead. If this
/// property is a number, it also indicates the number of pixels by which to offset the first
/// and last labels; for example, a value of 2 will flush-align the first and last labels and
/// also push them 2 pixels outward from the center of the axis. The additional adjustment
/// can sometimes help the labels better visually group with corresponding axis ticks.
///
/// __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum LabelFlush {
    Bool(bool),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalAxisPropertyStringNull {
    StickyExprRef(StickyExprRef),
    String(String),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct StickyExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<FluffyConditionalPredicateValueDefStringNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FluffyConditionalPredicateValueDefStringNullExprRef {
    ConditionalPredicateValueDefStringNullExprRefArray(
        Vec<ConditionalPredicateValueDefStringNullExprRef>,
    ),
    PurpleConditionalPredicateValueDefStringNullExprRef(
        PurpleConditionalPredicateValueDefStringNullExprRef,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefStringNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleConditionalPredicateValueDefStringNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ConditionalAxisPropertyFontStyleNull {
    IndigoExprRef(IndigoExprRef),
    String(String),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct IndigoExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<FluffyConditionalPredicateValueDefFontStyleNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FluffyConditionalPredicateValueDefFontStyleNullExprRef {
    ConditionalPredicateValueDefFontStyleNullExprRefArray(
        Vec<ConditionalPredicateValueDefFontStyleNullExprRef>,
    ),
    PurpleConditionalPredicateValueDefFontStyleNullExprRef(
        PurpleConditionalPredicateValueDefFontStyleNullExprRef,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefFontStyleNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleConditionalPredicateValueDefFontStyleNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FontWeight {
    Double(f64),
    Enum(FontWeightEnum),
    IndecentExprRef(IndecentExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct IndecentExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<FluffyConditionalPredicateValueDefFontWeightNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ValueUnion>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FluffyConditionalPredicateValueDefFontWeightNullExprRef {
    ConditionalPredicateValueDefFontWeightNullExprRefArray(
        Vec<ConditionalPredicateValueDefFontWeightNullExprRef>,
    ),
    PurpleConditionalPredicateValueDefFontWeightNullExprRef(
        PurpleConditionalPredicateValueDefFontWeightNullExprRef,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConditionalPredicateValueDefFontWeightNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ValueUnion>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ValueUnion {
    Double(f64),
    Enum(FontWeightEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleConditionalPredicateValueDefFontWeightNullExprRef {
    /// Predicate for triggering the condition
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub test: Option<PredicateCompositionElement>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ValueUnion>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TickBandUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(TickBandEnum),
}

/// For band scales, indicates if ticks and grid lines should be placed at the `"center"` of
/// a band (default) or at the band `"extent"`s to indicate intervals
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TickBandEnum {
    Center,
    Extent,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AxisTickDash {
    DoubleArray(Vec<f64>),
    HilariousExprRef(HilariousExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct HilariousExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<TentacledConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ImputeParams {
    /// A frame specification as a two-element array used to control the window over which the
    /// specified method is applied. The array entries should either be a number indicating the
    /// offset from the current data object, or null to indicate unbounded rows preceding or
    /// following the current data object. For example, the value `[-5, 5]` indicates that the
    /// window should include five objects preceding and five objects following the current
    /// object.
    ///
    /// __Default value:__:  `[null, null]` indicating that the window includes all objects.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub frame: Option<Vec<Option<f64>>>,
    /// Defines the key values that should be considered for imputation. An array of key values
    /// or an object defining a [number
    /// sequence](https://vega.github.io/vega-lite/docs/impute.html#sequence-def).
    ///
    /// If provided, this will be used in addition to the key values observed within the input
    /// data. If not provided, the values will be derived from all unique values of the `key`
    /// field. For `impute` in `encoding`, the key field is the x-field if the y-field is
    /// imputed, or vice versa.
    ///
    /// If there is no impute grouping, this property _must_ be specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub keyvals: Option<Keyvals>,
    /// The imputation method to use for the field value of imputed data objects. One of
    /// `"value"`, `"mean"`, `"median"`, `"max"` or `"min"`.
    ///
    /// __Default value:__  `"value"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub method: Option<ImputeParamsMethod>,
    /// The field value to use when the imputation `method` is `"value"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Keyvals {
    AnythingArray(Vec<Option<serde_json::Value>>),
    ImputeSequence(ImputeSequence),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ImputeSequence {
    /// The starting value of the sequence. __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start: Option<f64>,
    /// The step value between sequence entries. __Default value:__ `1` or `-1` if `stop < start`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// The ending value(exclusive) of the sequence.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stop: Option<f64>,
}

/// The imputation method to use for the field value of imputed data objects. One of
/// `"value"`, `"mean"`, `"median"`, `"max"` or `"min"`.
///
/// __Default value:__  `"value"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ImputeParamsMethod {
    Max,
    Mean,
    Median,
    Min,
    Value,
}

/// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
/// `"rule"`.
///
/// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
/// and  `"rule"`.
///
/// The inner radius in pixels of arc marks.
///
/// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
/// values proceed clockwise.
///
/// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct X2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position2_def_type: Option<Type>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

/// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of x coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of y coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct XErrorClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of x coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of y coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct XError2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// Offset of x-position of the marks
///
/// Offset of y-position of the marks
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct XOffsetClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
/// `x2` or `width`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
/// `y2` or `height`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct YClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// An object defining properties of axis's gridlines, ticks and labels. If `null`, the axis
    /// for the encoding channel will be removed.
    ///
    /// __Default value:__ If undefined, default [axis
    /// properties](https://vega.github.io/vega-lite/docs/axis.html) are applied.
    ///
    /// __See also:__ [`axis`](https://vega.github.io/vega-lite/docs/axis.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub axis: RemovableValue<Axis>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<DescriptionBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining the properties of the Impute Operation to be applied. The field value
    /// of the other positional channel is taken as `key` of the `Impute` Operation. The field of
    /// the `color` channel if specified is used as `groupby` of the `Impute` Operation.
    ///
    /// __See also:__ [`impute`](https://vega.github.io/vega-lite/docs/impute.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub impute: Option<ImputeParams>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Type of stacking offset if the field should be stacked. `stack` is only applicable for
    /// `x`, `y`, `theta`, and `radius` channels with continuous domains. For example, `stack` of
    /// `y` can be used to customize stacking for a vertical bar chart.
    ///
    /// `stack` can be one of the following values:
    /// - `"zero"` or `true`: stacking with baseline offset at zero value of the scale (for
    /// creating typical stacked [bar](https://vega.github.io/vega-lite/docs/stack.html#bar) and
    /// [area](https://vega.github.io/vega-lite/docs/stack.html#area) chart).
    /// - `"normalize"` - stacking with normalized domain (for creating [normalized stacked bar
    /// and area charts](https://vega.github.io/vega-lite/docs/stack.html#normalized) and pie
    /// charts [with percentage
    /// tooltip](https://vega.github.io/vega-lite/docs/arc.html#tooltip)). <br/>
    /// -`"center"` - stacking with center baseline (for
    /// [streamgraph](https://vega.github.io/vega-lite/docs/stack.html#streamgraph)).
    /// - `null` or `false` - No-stacking. This will produce layered
    /// [bar](https://vega.github.io/vega-lite/docs/stack.html#layered-bar-chart) and area
    /// chart.
    ///
    /// __Default value:__ `zero` for plots with all of the following conditions are true: (1)
    /// the mark is `bar`, `area`, or `arc`; (2) the stacked measure channel (x or y) has a
    /// linear scale; (3) At least one of non-position channels mapped to an unaggregated field
    /// that is different from x and y. Otherwise, `null` by default.
    ///
    /// __See also:__ [`stack`](https://vega.github.io/vega-lite/docs/stack.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stack: Option<Stack>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

/// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
/// `"rule"`.
///
/// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
/// and  `"rule"`.
///
/// The inner radius in pixels of arc marks.
///
/// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
/// values proceed clockwise.
///
/// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
///
/// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Y2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position2_def_type: Option<Type>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Latitude2Value>,
}

/// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of x coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of y coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct YErrorClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of x coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
///
/// Secondary error value of y coordinates for error specified `"errorbar"` and
/// `"errorband"`.
///
/// A field definition of a secondary channel that shares a scale with another primary
/// channel. For example, `x2`, `xError` and `xError2` share the same scale with `x`.
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct YError2Class {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<serde_json::Value>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// Offset of x-position of the marks
///
/// Offset of y-position of the marks
///
/// Definition object for a constant value (primitive value or gradient definition) of an
/// encoding channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct YOffsetClass {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of the channel's scale, which is the function that
    /// transforms values in the data domain (numbers, dates, strings, etc) to visual values
    /// (pixels, colors, sizes) of the encoding channels.
    ///
    /// If `null`, the scale will be [disabled and the data value will be directly
    /// encoded](https://vega.github.io/vega-lite/docs/scale.html#disable).
    ///
    /// __Default value:__ If undefined, default [scale
    /// properties](https://vega.github.io/vega-lite/docs/scale.html) are applied.
    ///
    /// __See also:__ [`scale`](https://vega.github.io/vega-lite/docs/scale.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub scale: RemovableValue<Scale>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A string indicating an encoding channel name to sort
    /// by](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding) (e.g., `"x"` or
    /// `"y"`) with an optional minus prefix for descending sort (e.g., `"-x"` to sort by
    /// x-field, descending). This channel string is short-form of [a sort-by-encoding
    /// definition](https://vega.github.io/vega-lite/docs/sort.html#sort-by-encoding). For
    /// example, `"sort": "-x"` is equivalent to `"sort": {"encoding": "x", "order":
    /// "descending"}`.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` and sorting by another channel is not supported for `row` and `column`.
    ///
    /// __See also:__ [`sort`](https://vega.github.io/vega-lite/docs/sort.html) documentation.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortUnion>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset_def_type: Option<Type>,
    /// A constant value in data domain.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub datum: Option<PrimitiveValue>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// Definition for how to facet the data. One of: 1) [a field definition for faceting the
/// plot by one field](https://vega.github.io/vega-lite/docs/facet.html#field-def) 2) [An
/// object that maps `row` and `column` channels to their field
/// definitions](https://vega.github.io/vega-lite/docs/facet.html#mapping)
///
/// A field definition for the horizontal facet of trellis plots.
///
/// A field definition for the vertical facet of trellis plots.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Facet {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of a facet's header.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header: Option<Header>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` is not supported for `row` and `column`.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortArray>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet_type: Option<StandardType>,
    /// A field definition for the horizontal facet of trellis plots.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<FacetFieldDef>,
    /// A field definition for the vertical facet of trellis plots.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<FacetFieldDef>,
}

/// A field definition for the horizontal facet of trellis plots.
///
/// A field definition for the vertical facet of trellis plots.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FacetFieldDef {
    /// Aggregation function for the field (e.g., `"mean"`, `"sum"`, `"median"`, `"min"`,
    /// `"max"`, `"count"`).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Aggregate>,
    /// Relative position on a band of a stacked, binned, time unit, or band scale. For example,
    /// the marks will be positioned at the beginning of the band if set to `0`, and at the
    /// middle of the band if set to `0.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<f64>,
    /// A flag for binning a `quantitative` field, [an object defining binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters), or indicating
    /// that the data for `x` or `y` channel are binned before they are imported into Vega-Lite
    /// (`"binned"`).
    ///
    /// - If `true`, default [binning
    /// parameters](https://vega.github.io/vega-lite/docs/bin.html#bin-parameters) will be
    /// applied.
    ///
    /// - If `"binned"`, this indicates that the data for the `x` (or `y`) channel are already
    /// binned. You can map the bin-start field to `x` (or `y`) and the bin-end field to `x2` (or
    /// `y2`). The scale and axis will be formatted similar to binning in Vega-Lite.  To adjust
    /// the axis ticks based on the bin step, you can also set the axis's
    /// [`tickMinStep`](https://vega.github.io/vega-lite/docs/axis.html#ticks) property.
    ///
    /// __Default value:__ `false`
    ///
    /// __See also:__ [`bin`](https://vega.github.io/vega-lite/docs/bin.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// __Required.__ A string defining the name of the field from which to pull a data value or
    /// an object defining iterated values from the
    /// [`repeat`](https://vega.github.io/vega-lite/docs/repeat.html) operator.
    ///
    /// __See also:__ [`field`](https://vega.github.io/vega-lite/docs/field.html) documentation.
    ///
    /// __Notes:__ 1)  Dots (`.`) and brackets (`[` and `]`) can be used to access nested objects
    /// (e.g., `"field": "foo.bar"` and `"field": "foo['bar']"`). If field names contain dots or
    /// brackets but are not nested, you can use `\\` to escape dots and brackets (e.g.,
    /// `"a\\.b"` and `"a\\[0\\]"`). See more details about escaping in the [field
    /// documentation](https://vega.github.io/vega-lite/docs/field.html). 2) `field` is not
    /// required if `aggregate` is `count`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<Field>,
    /// An object defining properties of a facet's header.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header: Option<Header>,
    /// Sort order for the encoded field.
    ///
    /// For continuous fields (quantitative or temporal), `sort` can be either `"ascending"` or
    /// `"descending"`.
    ///
    /// For discrete fields, `sort` can be one of the following:
    /// - `"ascending"` or `"descending"` -- for sorting by the values' natural order in
    /// JavaScript.
    /// - [A sort field definition](https://vega.github.io/vega-lite/docs/sort.html#sort-field)
    /// for sorting by another field.
    /// - [An array specifying the field values in preferred
    /// order](https://vega.github.io/vega-lite/docs/sort.html#sort-array). In this case, the
    /// sort order will obey the values in the array, followed by any unspecified values in their
    /// original order. For discrete time field, values in the sort array can be [date-time
    /// definition objects](struct.DateTime.html). In addition, for time units `"month"` and `"day"`,
    /// the values can be the month or day names (case insensitive) or their 3-letter initials
    /// (e.g., `"Mon"`, `"Tue"`).
    /// - `null` indicating no sort.
    ///
    /// __Default value:__ `"ascending"`
    ///
    /// __Note:__ `null` is not supported for `row` and `column`.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub sort: RemovableValue<SortArray>,
    /// Time unit (e.g., `year`, `yearmonth`, `month`, `hours`) for a temporal field. or [a
    /// temporal field that gets casted as
    /// ordinal](https://vega.github.io/vega-lite/docs/type.html#cast).
    ///
    /// __Default value:__ `undefined` (None)
    ///
    /// __See also:__ [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html)
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<LogicalNotPredicateTimeUnit>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    /// The type of measurement (`"quantitative"`, `"temporal"`, `"ordinal"`, or `"nominal"`) for
    /// the encoded field or constant value (`datum`). It can also be a `"geojson"` type for
    /// encoding ['geoshape'](https://vega.github.io/vega-lite/docs/geoshape.html).
    ///
    /// Vega-Lite automatically infers data types in many cases as discussed below. However, type
    /// is required for a field if: (1) the field is not nominal and the field encoding has no
    /// specified `aggregate` (except `argmin` and `argmax`), `bin`, scale type, custom `sort`
    /// order, nor `timeUnit` or (2) if you wish to use an ordinal scale for a field with `bin`
    /// or `timeUnit`.
    ///
    /// __Default value:__
    ///
    /// 1) For a data `field`, `"nominal"` is the default data type unless the field encoding has
    /// `aggregate`, `channel`, `bin`, scale type, `sort`, or `timeUnit` that satisfies the
    /// following criteria:
    /// - `"quantitative"` is the default type if (1) the encoded field contains `bin` or
    /// `aggregate` except `"argmin"` and `"argmax"`, (2) the encoding channel is `latitude` or
    /// `longitude` channel or (3) if the specified scale type is [a quantitative
    /// scale](https://vega.github.io/vega-lite/docs/scale.html#type).
    /// - `"temporal"` is the default type if (1) the encoded field contains `timeUnit` or (2)
    /// the specified scale type is a time or utc scale
    /// - `"ordinal"` is the default type if (1) the encoded field contains a [custom `sort`
    /// order](https://vega.github.io/vega-lite/docs/sort.html#specifying-custom-sort-order), (2)
    /// the specified scale type is an ordinal/point/band scale, or (3) the encoding channel is
    /// `order`.
    ///
    /// 2) For a constant value in data domain (`datum`):
    /// - `"quantitative"` if the datum is a number
    /// - `"nominal"` if the datum is a string
    /// - `"temporal"` if the datum is [a date time
    /// object](https://vega.github.io/vega-lite/docs/datetime.html)
    ///
    /// __Note:__
    /// - Data `type` describes the semantics of the data rather than the primitive data types
    /// (number, string, etc.). The same primitive data type can have different types of
    /// measurement. For example, numeric data can represent quantitative, ordinal, or nominal
    /// data.
    /// - Data values for a temporal field can be either a date-time string (e.g., `"2015-03-07
    /// 12:32:17"`, `"17:01"`, `"2015-03-16"`. `"2015"`) or a timestamp number (e.g.,
    /// `1552199579097`).
    /// - When using with [`bin`](https://vega.github.io/vega-lite/docs/bin.html), the `type`
    /// property can be either `"quantitative"` (for using a linear bin scale) or [`"ordinal"`
    /// (for using an ordinal bin
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`timeUnit`](https://vega.github.io/vega-lite/docs/timeunit.html), the
    /// `type` property can be either `"temporal"` (default, for using a temporal scale) or
    /// [`"ordinal"` (for using an ordinal
    /// scale)](https://vega.github.io/vega-lite/docs/type.html#cast-bin).
    /// - When using with [`aggregate`](https://vega.github.io/vega-lite/docs/aggregate.html),
    /// the `type` property refers to the post-aggregation data type. For example, we can
    /// calculate count `distinct` of a categorical field `"cat"` using `{"aggregate":
    /// "distinct", "field": "cat"}`. The `"type"` of the aggregate output is `"quantitative"`.
    /// - Secondary channels (e.g., `x2`, `y2`, `xError`, `yError`) do not have `type` as they
    /// must have exactly the same type as their primary channels (e.g., `x`, `y`).
    ///
    /// __See also:__ [`type`](https://vega.github.io/vega-lite/docs/type.html) documentation.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet_field_def_type: Option<StandardType>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum SpecHeight {
    Double(f64),
    Enum(HeightEnum),
    Step(Box<Step>),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Step {
    /// Whether to apply the step to position scale or offset scale when there are both `x` and
    /// `xOffset` or both `y` and `yOffset` encodings.
    #[serde(rename = "for")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step_for: Option<StepFor>,
    /// The size (width/height) per discrete step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
}

/// Whether to apply the step to position scale or offset scale when there are both `x` and
/// `xOffset` or both `y` and `yOffset` encodings.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StepFor {
    Offset,
    Position,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HeightEnum {
    Container,
}

/// A full layered plot specification, which may contains `encoding` and `projection`
/// properties that will be applied to underlying unit (single-view) specifications.
///
/// A unit specification, which can contain either [primitive marks or composite
/// marks](https://vega.github.io/vega-lite/docs/mark.html#types).
///
/// Base interface for a unit (single-view) specification.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LayerSpec {
    /// An object describing the data source. Set to `null` to ignore the parent's data source.
    /// If no data is set, it is derived from the parent.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub data: RemovableValue<UrlData>,
    /// Description of this mark for commenting purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<String>,
    /// A shared key-value mapping between encoding channels and definition of fields in the
    /// underlying layers.
    ///
    /// A key-value mapping between encoding channels and definition of fields.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<LayerEncoding>,
    /// The height of a visualization.
    ///
    /// - For a plot with a continuous y-field, height should be a number.
    /// - For a plot with either a discrete y-field or no y-field, height can be either a number
    /// indicating a fixed height or an object in the form of `{step: number}` defining the
    /// height per discrete step. (No y-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on height, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousHeight` for a plot with a continuous
    /// y-field and `config.view.discreteHeight` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// height of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`height`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<SpecHeight>,
    /// Layer or single view specifications to be layered.
    ///
    /// __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
    /// layering facet specifications is not allowed. Instead, use the [facet
    /// operator](https://vega.github.io/vega-lite/docs/facet.html) and place a layer inside a
    /// facet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layer: Option<Vec<LayerSpec>>,
    /// Name of the visualization for later reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An object defining properties of the geographic projection shared by underlying layers.
    ///
    /// An object defining properties of geographic projection, which will be applied to `shape`
    /// path for `"geoshape"` marks and to `latitude` and `"longitude"` channels for other marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection: Option<Box<Projection>>,
    /// Scale, axis, and legend resolutions for view composition specifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<Box<Resolve>>,
    /// Title for the plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title: Option<TitleUnion>,
    /// An array of data transformations such as filter and new field calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform: Option<Vec<Transform>>,
    /// An object defining the view background's fill and stroke.
    ///
    /// __Default value:__ none (transparent)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub view: Option<Box<ViewBackground>>,
    /// The width of a visualization.
    ///
    /// - For a plot with a continuous x-field, width should be a number.
    /// - For a plot with either a discrete x-field or no x-field, width can be either a number
    /// indicating a fixed width or an object in the form of `{step: number}` defining the width
    /// per discrete step. (No x-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on width, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousWidth` for a plot with a continuous
    /// x-field and `config.view.discreteWidth` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// width of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`width`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<SpecHeight>,
    /// A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
    /// `"line"`, `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark
    /// definition object](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<AnyMark>,
    /// An array of parameters that may either be simple variables, or more complex selections
    /// that map user input to data queries.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<Vec<SelectionParameter>>,
}

/// A shared key-value mapping between encoding channels and definition of fields in the
/// underlying layers.
///
/// A key-value mapping between encoding channels and definition of fields.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LayerEncoding {
    /// Rotation angle of point and text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<AngleClass>,
    /// Color of the marks – either fill or stroke color based on  the `filled` property of mark
    /// definition. By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
    /// `"text"`, `"trail"`, `"circle"`, and `"square"` / stroke color for `"line"` and
    /// `"point"`.
    ///
    /// __Default value:__ If undefined, the default color depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ 1) For fine-grained control over both fill and stroke colors of the marks, please
    /// use the `fill` and `stroke` channels. The `fill` or `stroke` encodings have higher
    /// precedence than `color`, thus may override the `color` encoding if conflicting encodings
    /// are specified. 2) See the scale documentation for more information about customizing
    /// [color scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<ColorClass>,
    /// A text description of this mark for ARIA accessibility (SVG output only). For SVG output
    /// the `"aria-label"` attribute will be set to this description.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<DescriptionClass>,
    /// Additional levels of detail for grouping data in aggregate views and in line, trail, and
    /// area marks without mapping data to a specific visual channel.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub detail: Option<Detail>,
    /// Fill color of the marks. __Default value:__ If undefined, the default color depends on
    /// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ The `fill` encoding has higher precedence than `color`, thus may override the
    /// `color` encoding if conflicting encodings are specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<FillClass>,
    /// Fill opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<FillOpacityClass>,
    /// A URL to load upon mouse click.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<HrefClass>,
    /// A data field to use as a unique key for data binding. When a visualization’s data is
    /// updated, the key value will be used to match data elements to existing mark instances.
    /// Use a key channel to enable object constancy for transitions over dynamic data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub key: Option<KeyClass>,
    /// Latitude position of geographically projected marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub latitude: Option<LatitudeClass>,
    /// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
    /// `"rule"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub latitude2: Option<Latitude2Class>,
    /// Longitude position of geographically projected marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub longitude: Option<LongitudeClass>,
    /// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
    /// and  `"rule"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub longitude2: Option<Longitude2Class>,
    /// Opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<OpacityClass>,
    /// Order of the marks.
    /// - For stacked marks, this `order` channel encodes [stack
    /// order](https://vega.github.io/vega-lite/docs/stack.html#order).
    /// - For line and trail marks, this `order` channel encodes order of data points in the
    /// lines. This can be useful for creating [a connected
    /// scatterplot](https://vega.github.io/vega-lite/examples/connected_scatterplot.html).
    /// Setting `order` to `{"value": null}` makes the line marks use the original order in the
    /// data sources.
    /// - Otherwise, this `order` channel encodes layer order of the marks.
    ///
    /// __Note__: In aggregate plots, `order` field should be `aggregate`d to avoid creating
    /// additional aggregation grouping.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<Order>,
    /// The outer radius in pixels of arc marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<RadiusClass>,
    /// The inner radius in pixels of arc marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<Radius2Class>,
    /// Shape of the mark.
    ///
    /// 1. For `point` marks the supported values include:   - plotting shapes: `"circle"`,
    /// `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`, `"triangle-down"`,
    /// `"triangle-right"`, or `"triangle-left"`.   - the line symbol `"stroke"`   - centered
    /// directional shapes `"arrow"`, `"wedge"`, or `"triangle"`   - a custom [SVG path
    /// string](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths) (For correct
    /// sizing, custom shape paths should be defined within a square bounding box with
    /// coordinates ranging from -1 to 1 along both the x and y dimensions.)
    ///
    /// 2. For `geoshape` marks it should be a field definition of the geojson data
    ///
    /// __Default value:__ If undefined, the default shape depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#point-config)'s `shape`
    /// property. (`"circle"` if unset.)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<MarkPropDefStringNullTypeForShape>,
    /// Size of the mark.
    /// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
    /// - For `"bar"` and `"tick"` – the bar and tick's size.
    /// - For `"text"` – the text's font size.
    /// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
    /// line with varying size)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<SizeClass>,
    /// Stroke color of the marks. __Default value:__ If undefined, the default color depends on
    /// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ The `stroke` encoding has higher precedence than `color`, thus may override the
    /// `color` encoding if conflicting encodings are specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<StrokeClass>,
    /// Stroke dash of the marks.
    ///
    /// __Default value:__ `[1,0]` (No dash).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<MarkPropDefNumber>,
    /// Stroke opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<StrokeOpacityClass>,
    /// Stroke width of the marks.
    ///
    /// __Default value:__ If undefined, the default stroke width depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<StrokeWidthClass>,
    /// Text of the `text` mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<TextDef>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<ThetaClass>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<Theta2Class>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<TimeFieldDef>,
    /// The tooltip text to show upon mouse hover. Specifying `tooltip` encoding overrides [the
    /// `tooltip` property in the mark
    /// definition](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip in Vega-Lite.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<EncodingTooltip>,
    /// The URL of an image mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<UrlClass>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XClass>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<X2Class>,
    /// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_error: Option<XErrorClass>,
    /// Secondary error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_error2: Option<XError2Class>,
    /// Offset of x-position of the marks
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<XOffsetClass>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YClass>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<Y2Class>,
    /// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_error: Option<YErrorClass>,
    /// Secondary error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_error2: Option<YError2Class>,
    /// Offset of y-position of the marks
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<YOffsetClass>,
}

/// A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
/// `"line"`, `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark
/// definition object](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AnyMark {
    Def(Def),
    Enum(Mark),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Def {
    #[serde(rename = "box")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub def_box: Option<AnyMarkConfig>,
    /// Whether a composite mark be clipped to the enclosing group’s width and height.
    ///
    /// Whether a mark be clipped to the enclosing group’s width and height.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip: Option<Aria>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    /// The extent of the whiskers. Available options include:
    /// - `"min-max"`: min and max are the lower and upper whiskers respectively.
    /// - A number representing multiple of the interquartile range. This number will be
    /// multiplied by the IQR to determine whisker boundary, which spans from the smallest data
    /// to the largest data within the range _[Q1 - k * IQR, Q3 + k * IQR]_ where _Q1_ and _Q3_
    /// are the first and third quartiles while _IQR_ is the interquartile range (_Q3-Q1_).
    ///
    /// __Default value:__ `1.5`.
    ///
    /// The extent of the rule. Available options include:
    /// - `"ci"`: Extend the rule to the 95% bootstrapped confidence interval of the mean.
    /// - `"stderr"`: The size of rule are set to the value of standard error, extending from the
    /// mean.
    /// - `"stdev"`: The size of rule are set to the value of standard deviation, extending from
    /// the mean.
    /// - `"iqr"`: Extend the rule to the q1 and q3.
    ///
    /// __Default value:__ `"stderr"`.
    ///
    /// The extent of the band. Available options include:
    /// - `"ci"`: Extend the band to the 95% bootstrapped confidence interval of the mean.
    /// - `"stderr"`: The size of band are set to the value of standard error, extending from the
    /// mean.
    /// - `"stdev"`: The size of band are set to the value of standard deviation, extending from
    /// the mean.
    /// - `"iqr"`: Extend the band to the q1 and q3.
    ///
    /// __Default value:__ `"stderr"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<MarkDefExtent>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub median: Option<AnyMarkConfig>,
    /// The opacity (value between [0,1]) of the mark.
    ///
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<Opacity>,
    /// Orientation of the box plot. This is normally automatically determined based on types of
    /// fields on x and y channels. However, an explicit `orient` be specified when the
    /// orientation is ambiguous.
    ///
    /// __Default value:__ `"vertical"`.
    ///
    /// Orientation of the error bar. This is normally automatically determined, but can be
    /// specified when the orientation is ambiguous and cannot be automatically determined.
    ///
    /// Orientation of the error band. This is normally automatically determined, but can be
    /// specified when the orientation is ambiguous and cannot be automatically determined.
    ///
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outliers: Option<AnyMarkConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rule: Option<AnyMarkConfig>,
    /// Size of the box and median tick of a box plot
    ///
    /// Size of the ticks of an error bar
    ///
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ticks: Option<AnyMarkConfig>,
    /// The mark type. This could a primitive mark type (one of `"bar"`, `"circle"`, `"square"`,
    /// `"tick"`, `"line"`, `"area"`, `"point"`, `"geoshape"`, `"rule"`, and `"text"`) or a
    /// composite mark type (`"boxplot"`, `"errorband"`, `"errorbar"`).
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub def_type: Option<Mark>,
    /// Thickness of the ticks and the bar of an error bar
    ///
    /// Thickness of the tick mark.
    ///
    /// __Default value:__  `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub thickness: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band: Option<AnyMarkConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub borders: Option<AnyMarkConfig>,
    /// The line interpolation method for the error band. One of the following:
    /// - `"linear"`: piecewise linear segments, as in a polyline.
    /// - `"linear-closed"`: close the linear segments to form a polygon.
    /// - `"step"`: 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.
    /// - `"step-before"`: a piecewise constant function (a step function) consisting of
    /// alternating horizontal and vertical lines. The y-value changes before the x-value.
    /// - `"step-after"`: a piecewise constant function (a step function) consisting of
    /// alternating horizontal and vertical lines. The y-value changes after the x-value.
    /// - `"basis"`: a B-spline, with control point duplication on the ends.
    /// - `"basis-open"`: an open B-spline; may not intersect the start or end.
    /// - `"basis-closed"`: a closed B-spline, as in a loop.
    /// - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
    /// - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
    /// will intersect other control points.
    /// - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
    /// - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
    /// spline.
    /// - `"monotone"`: cubic interpolation that preserves monotonicity in y.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// The tension parameter for the interpolation type of the error band.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<Opacity>,
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// The width of the ticks.
    ///
    /// __Default value:__  3/4 of step (width step for horizontal ticks and height step for
    /// vertical ticks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_size: Option<f64>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    /// Offset between bars for binned field. The ideal value for this is either 0 (preferred by
    /// statisticians) or 1 (Vega-Lite default, D3 example style).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin_spacing: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// The default size of the bars on continuous scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_band_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    /// - For vertical bars, top-left and top-right corner radius.
    ///
    /// - For horizontal bars, top-right and bottom-right corner radius.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_end: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    /// The default size of the bars with discrete dimensions. If unspecified, the default size
    /// is  `step-2`, which provides 2 pixel offset between bars.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_band_size: Option<DiscreteBandSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    /// Height of the marks.  One of:
    ///
    /// - A number representing a fixed pixel height.
    ///
    /// - A relative band size definition.  For example, `{band: 0.5}` represents half of the band
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<BoxPlotDefHeight>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    /// A flag for overlaying line on top of area marks, or an object defining the properties of
    /// the overlayed lines.
    ///
    /// - If this value is an empty object (`{}`) or `true`, lines with default properties will
    /// be used.
    ///
    /// - If this value is `false`, no lines would be automatically added to area marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line: Option<Line>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The minimum band size for bar and rectangle marks. __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// A flag for overlaying points on top of line or area marks, or an object defining the
    /// properties of the overlayed points.
    ///
    /// - If this property is `"transparent"`, transparent points will be used (for enhancing
    /// tooltips and selections).
    ///
    /// - If this property is an empty object (`{}`) or `true`, filled points with default
    /// properties will be used.
    ///
    /// - If this property is `false`, no points would be automatically added to line or area
    /// marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<PointUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    /// Offset for radius2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2_offset: Option<CornerRadiusUnion>,
    /// Offset for radius.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    /// A string or array of strings indicating the name of custom styles to apply to the mark. A
    /// style is a named collection of mark property defaults defined within the [style
    /// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
    /// an array, later styles will override earlier styles. Any [mark
    /// properties](https://vega.github.io/vega-lite/docs/encoding.html#mark-prop) explicitly
    /// defined within the `encoding` will override a style default.
    ///
    /// __Default value:__ The mark's name. For example, a bar mark will have style `"bar"` by
    /// default. __Note:__ Any specified style will augment the default style. For example, a bar
    /// mark with `"style": "foo"` will receive from `config.style.bar` and `config.style.foo`
    /// (the specified style `"foo"` has higher precedence).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    /// Offset for theta2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2_offset: Option<CornerRadiusUnion>,
    /// Offset for theta.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    /// Width of the marks.  One of:
    ///
    /// - A number representing a fixed pixel width.
    ///
    /// - A relative band size definition.  For example, `{band: 0.5}` represents half of the
    /// band.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<BoxPlotDefHeight>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Offset for x2-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2_offset: Option<CornerRadiusUnion>,
    /// Offset for x-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<CornerRadiusUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
    /// Offset for y2-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2_offset: Option<CornerRadiusUnion>,
    /// Offset for y-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<CornerRadiusUnion>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Angle {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AnyMarkConfig {
    Bool(bool),
    Config(Config),
}

/// Circle-Specific Config
///
/// Geoshape-Specific Config
///
/// Mark Config
///
/// Point-Specific Config
///
/// Rule-Specific Config
///
/// Square-Specific Config
///
/// Default style for chart subtitles
///
/// Default style for chart titles
///
/// Default style for axis, legend, and header labels.
///
/// Default style for axis, legend, and header titles.
///
/// Text-Specific Config
///
/// Area-Specific Config
///
/// Bar-Specific Config
///
/// Arc-specific Config
///
/// Image-specific Config
///
/// Rect-Specific Config
///
/// Line-Specific Config
///
/// Trail-Specific Config
///
/// Tick-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Config {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
    /// A flag for overlaying line on top of area marks, or an object defining the properties of
    /// the overlayed lines.
    ///
    /// - If this value is an empty object (`{}`) or `true`, lines with default properties will
    /// be used.
    ///
    /// - If this value is `false`, no lines would be automatically added to area marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line: Option<Line>,
    /// A flag for overlaying points on top of line or area marks, or an object defining the
    /// properties of the overlayed points.
    ///
    /// - If this property is `"transparent"`, transparent points will be used (for enhancing
    /// tooltips and selections).
    ///
    /// - If this property is an empty object (`{}`) or `true`, filled points with default
    /// properties will be used.
    ///
    /// - If this property is `false`, no points would be automatically added to line or area
    /// marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<PointUnion>,
    /// Offset between bars for binned field. The ideal value for this is either 0 (preferred by
    /// statisticians) or 1 (Vega-Lite default, D3 example style).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin_spacing: Option<f64>,
    /// The default size of the bars on continuous scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_band_size: Option<f64>,
    /// - For vertical bars, top-left and top-right corner radius.
    ///
    /// - For horizontal bars, top-right and bottom-right corner radius.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_end: Option<CornerRadiusUnion>,
    /// The default size of the bars with discrete dimensions. If unspecified, the default size
    /// is  `step-2`, which provides 2 pixel offset between bars.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_band_size: Option<DiscreteBandSize>,
    /// The minimum band size for bar and rectangle marks. __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<CornerRadiusUnion>,
    /// The width of the ticks.
    ///
    /// __Default value:__  3/4 of step (width step for horizontal ticks and height step for
    /// vertical ticks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_size: Option<f64>,
    /// Thickness of the tick mark.
    ///
    /// __Default value:__  `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub thickness: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum BlendUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(BlendEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum BlendEnum {
    Color,
    #[serde(rename = "color-burn")]
    ColorBurn,
    #[serde(rename = "color-dodge")]
    ColorDodge,
    Darken,
    Difference,
    Exclusion,
    #[serde(rename = "hard-light")]
    HardLight,
    Hue,
    Lighten,
    Luminosity,
    Multiply,
    Overlay,
    Saturation,
    Screen,
    #[serde(rename = "soft-light")]
    SoftLight,
}

/// Default color.
///
/// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
///
/// __Note:__
/// - This property cannot be used in a [style
/// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
/// - The `fill` and `stroke` properties have higher precedence than `color` and will
/// override `color`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum MarkConfigColor {
    ColorLinearGradient(ColorLinearGradient),
    String(String),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ColorLinearGradient {
    /// The type of gradient. Use `"linear"` for a linear gradient.
    ///
    /// The type of gradient. Use `"radial"` for a radial gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient: Option<Gradient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<String>,
    /// An array of gradient stops defining the gradient color sequence.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stops: Option<Vec<GradientStop>>,
    /// The starting x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x1: Option<f64>,
    /// The ending x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `1`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<f64>,
    /// The starting y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y1: Option<f64>,
    /// The ending y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the inner circle for the
    /// gradient.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r1: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the outer circle for the
    /// gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r2: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum CursorUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(Cursor),
}

/// The mouse cursor used over the mark. Any valid [CSS cursor
/// type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
///
/// The mouse cursor used over the interval mark. Any valid [CSS cursor
/// type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
///
/// The mouse cursor used over the view. Any valid [CSS cursor
/// type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Cursor {
    Alias,
    #[serde(rename = "all-scroll")]
    AllScroll,
    Auto,
    Cell,
    #[serde(rename = "col-resize")]
    ColResize,
    #[serde(rename = "context-menu")]
    ContextMenu,
    Copy,
    Crosshair,
    Default,
    #[serde(rename = "e-resize")]
    EResize,
    #[serde(rename = "ew-resize")]
    EwResize,
    Grab,
    Grabbing,
    Help,
    Move,
    #[serde(rename = "n-resize")]
    NResize,
    #[serde(rename = "ne-resize")]
    NeResize,
    #[serde(rename = "nesw-resize")]
    NeswResize,
    #[serde(rename = "no-drop")]
    NoDrop,
    None,
    #[serde(rename = "not-allowed")]
    NotAllowed,
    #[serde(rename = "ns-resize")]
    NsResize,
    #[serde(rename = "nw-resize")]
    NwResize,
    #[serde(rename = "nwse-resize")]
    NwseResize,
    Pointer,
    Progress,
    #[serde(rename = "row-resize")]
    RowResize,
    #[serde(rename = "s-resize")]
    SResize,
    #[serde(rename = "se-resize")]
    SeResize,
    #[serde(rename = "sw-resize")]
    SwResize,
    Text,
    #[serde(rename = "vertical-text")]
    VerticalText,
    #[serde(rename = "w-resize")]
    WResize,
    Wait,
    #[serde(rename = "zoom-in")]
    ZoomIn,
    #[serde(rename = "zoom-out")]
    ZoomOut,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Dir {
    BackgroundExprRef(BackgroundExprRef),
    Enum(TextDirection),
}

/// The direction of the text. One of `"ltr"` (left-to-right) or `"rtl"` (right-to-left).
/// This property determines on which side is truncated in response to the limit parameter.
///
/// __Default value:__ `"ltr"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TextDirection {
    Ltr,
    Rtl,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DiscreteBandSize {
    Double(f64),
    RelativeBandSize(RelativeBandSize),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RelativeBandSize {
    /// The relative band size.  For example `0.5` means half of the band scale's band width.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum MarkConfigFill {
    FillLinearGradient(FillLinearGradient),
    String(String),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FillLinearGradient {
    /// The type of gradient. Use `"linear"` for a linear gradient.
    ///
    /// The type of gradient. Use `"radial"` for a radial gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient: Option<Gradient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<String>,
    /// An array of gradient stops defining the gradient color sequence.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stops: Option<Vec<GradientStop>>,
    /// The starting x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x1: Option<f64>,
    /// The ending x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `1`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<f64>,
    /// The starting y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y1: Option<f64>,
    /// The ending y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the inner circle for the
    /// gradient.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r1: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the outer circle for the
    /// gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r2: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Opacity {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum MarkConfigInterpolate {
    BackgroundExprRef(BackgroundExprRef),
    Enum(Interpolate),
}

/// The line interpolation method to use for line and area marks. One of the following:
/// - `"linear"`: piecewise linear segments, as in a polyline.
/// - `"linear-closed"`: close the linear segments to form a polygon.
/// - `"step"`: alternate between horizontal and vertical segments, as in a step function.
/// - `"step-before"`: alternate between vertical and horizontal segments, as in a step
/// function.
/// - `"step-after"`: alternate between horizontal and vertical segments, as in a step
/// function.
/// - `"basis"`: a B-spline, with control point duplication on the ends.
/// - `"basis-open"`: an open B-spline; may not intersect the start or end.
/// - `"basis-closed"`: a closed B-spline, as in a loop.
/// - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
/// - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
/// will intersect other control points.
/// - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
/// - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
/// spline.
/// - `"monotone"`: cubic interpolation that preserves monotonicity in y.
///
/// The line interpolation method for the error band. One of the following:
/// - `"linear"`: piecewise linear segments, as in a polyline.
/// - `"linear-closed"`: close the linear segments to form a polygon.
/// - `"step"`: 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.
/// - `"step-before"`: a piecewise constant function (a step function) consisting of
/// alternating horizontal and vertical lines. The y-value changes before the x-value.
/// - `"step-after"`: a piecewise constant function (a step function) consisting of
/// alternating horizontal and vertical lines. The y-value changes after the x-value.
/// - `"basis"`: a B-spline, with control point duplication on the ends.
/// - `"basis-open"`: an open B-spline; may not intersect the start or end.
/// - `"basis-closed"`: a closed B-spline, as in a loop.
/// - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
/// - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
/// will intersect other control points.
/// - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
/// - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
/// spline.
/// - `"monotone"`: cubic interpolation that preserves monotonicity in y.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Interpolate {
    Basis,
    #[serde(rename = "basis-closed")]
    BasisClosed,
    #[serde(rename = "basis-open")]
    BasisOpen,
    Bundle,
    Cardinal,
    #[serde(rename = "cardinal-closed")]
    CardinalClosed,
    #[serde(rename = "cardinal-open")]
    CardinalOpen,
    #[serde(rename = "catmull-rom")]
    CatmullRom,
    Linear,
    #[serde(rename = "linear-closed")]
    LinearClosed,
    Monotone,
    Natural,
    Step,
    #[serde(rename = "step-after")]
    StepAfter,
    #[serde(rename = "step-before")]
    StepBefore,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum MarkInvalidDataMode {
    #[serde(rename = "break-paths-filter-domains")]
    BreakPathsFilterDomains,
    #[serde(rename = "break-paths-show-domains")]
    BreakPathsShowDomains,
    #[serde(rename = "break-paths-show-path-domains")]
    BreakPathsShowPathDomains,
    Filter,
    Show,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Line {
    Bool(bool),
    OverlayMarkDef(OverlayMarkDef),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct OverlayMarkDef {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Whether a mark be clipped to the enclosing group’s width and height.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip: Option<Aria>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    /// Offset for radius2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2_offset: Option<CornerRadiusUnion>,
    /// Offset for radius.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    /// A string or array of strings indicating the name of custom styles to apply to the mark. A
    /// style is a named collection of mark property defaults defined within the [style
    /// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
    /// an array, later styles will override earlier styles. Any [mark
    /// properties](https://vega.github.io/vega-lite/docs/encoding.html#mark-prop) explicitly
    /// defined within the `encoding` will override a style default.
    ///
    /// __Default value:__ The mark's name. For example, a bar mark will have style `"bar"` by
    /// default. __Note:__ Any specified style will augment the default style. For example, a bar
    /// mark with `"style": "foo"` will receive from `config.style.bar` and `config.style.foo`
    /// (the specified style `"foo"` has higher precedence).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    /// Offset for theta2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2_offset: Option<CornerRadiusUnion>,
    /// Offset for theta.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Offset for x2-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2_offset: Option<CornerRadiusUnion>,
    /// Offset for x-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<CornerRadiusUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
    /// Offset for y2-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2_offset: Option<CornerRadiusUnion>,
    /// Offset for y-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<CornerRadiusUnion>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum StrokeJoinUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(StrokeJoin),
}

/// The stroke line join method. One of `"miter"`, `"round"` or `"bevel"`.
///
/// __Default value:__ `"miter"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StrokeJoin {
    Bevel,
    Miter,
    Round,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum OverlayMarkDefTooltip {
    Bool(bool),
    Double(f64),
    String(String),
    TooltipContent(TooltipContent),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TooltipContent {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub content: Option<Content>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Content {
    Data,
    Encoding,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum XUnion {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
    Enum(XEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum XEnum {
    Width,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum YUnion {
    BackgroundExprRef(BackgroundExprRef),
    Double(f64),
    Enum(YEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum YEnum {
    Height,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum PointUnion {
    Bool(bool),
    Enum(PointEnum),
    OverlayMarkDef(OverlayMarkDef),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PointEnum {
    Transparent,
}

/// The mark type. This could a primitive mark type (one of `"bar"`, `"circle"`, `"square"`,
/// `"tick"`, `"line"`, `"area"`, `"point"`, `"geoshape"`, `"rule"`, and `"text"`) or a
/// composite mark type (`"boxplot"`, `"errorband"`, `"errorbar"`).
///
/// All types of primitive marks.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Mark {
    Arc,
    Area,
    Bar,
    Boxplot,
    Circle,
    Errorband,
    Errorbar,
    Geoshape,
    Image,
    Line,
    Point,
    Rect,
    Rule,
    Square,
    Text,
    Tick,
    Trail,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum MarkDefExtent {
    Double(f64),
    Enum(ExtentExtent),
}

/// The extent of the band. Available options include:
/// - `"ci"`: Extend the band to the 95% bootstrapped confidence interval of the mean.
/// - `"stderr"`: The size of band are set to the value of standard error, extending from the
/// mean.
/// - `"stdev"`: The size of band are set to the value of standard deviation, extending from
/// the mean.
/// - `"iqr"`: Extend the band to the q1 and q3.
///
/// __Default value:__ `"stderr"`.
///
/// The extent of the rule. Available options include:
/// - `"ci"`: Extend the rule to the 95% bootstrapped confidence interval of the mean.
/// - `"stderr"`: The size of rule are set to the value of standard error, extending from the
/// mean.
/// - `"stdev"`: The size of rule are set to the value of standard deviation, extending from
/// the mean.
/// - `"iqr"`: Extend the rule to the q1 and q3.
///
/// __Default value:__ `"stderr"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ExtentExtent {
    Ci,
    Iqr,
    #[serde(rename = "min-max")]
    MinMax,
    Stderr,
    Stdev,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum BoxPlotDefHeight {
    Double(f64),
    RelativeBandSizeClass(RelativeBandSizeClass),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RelativeBandSizeClass {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    /// The relative band size.  For example `0.5` means half of the band scale's band width.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SelectionParameter {
    /// When set, a selection is populated by input elements (also known as dynamic query
    /// widgets) or by interacting with the corresponding legend. Direct manipulation interaction
    /// is disabled by default; to re-enable it, set the selection's
    /// [`on`](https://vega.github.io/vega-lite/docs/selection.html#common-selection-properties)
    /// property.
    ///
    /// Legend bindings are restricted to selections that only specify a single field or
    /// encoding.
    ///
    /// Query widget binding takes the form of Vega's [input element binding
    /// definition](https://vega.github.io/vega/docs/signals/#bind) or can be a mapping between
    /// projected field/encodings and binding definitions.
    ///
    /// __See also:__ [`bind`](https://vega.github.io/vega-lite/docs/bind.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bind: Option<ParamBind>,
    /// Required. A unique name for the selection parameter. Selection names should be valid
    /// JavaScript identifiers: they should contain only alphanumeric characters (or "$", or "_")
    /// and may not start with a digit. Reserved keywords that may not be used as parameter names
    /// are "datum", "event", "item", and "parent".
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// Determines the default event processing and data query for the selection. Vega-Lite
    /// currently supports two selection types:
    ///
    /// - `"point"` -- to select multiple discrete data values; the first value is selected on
    /// `click` and additional values toggled on shift-click.
    /// - `"interval"` -- to select a continuous range of data values on `drag`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub select: Option<ParamSelect>,
    /// Initialize the selection with a mapping between [projected channels or field
    /// names](https://vega.github.io/vega-lite/docs/selection.html#project) and initial values.
    ///
    /// __See also:__ [`init`](https://vega.github.io/vega-lite/docs/value.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ParamValue>,
}

/// When set, a selection is populated by input elements (also known as dynamic query
/// widgets) or by interacting with the corresponding legend. Direct manipulation interaction
/// is disabled by default; to re-enable it, set the selection's
/// [`on`](https://vega.github.io/vega-lite/docs/selection.html#common-selection-properties)
/// property.
///
/// Legend bindings are restricted to selections that only specify a single field or
/// encoding.
///
/// Query widget binding takes the form of Vega's [input element binding
/// definition](https://vega.github.io/vega/docs/signals/#bind) or can be a mapping between
/// projected field/encodings and binding definitions.
///
/// __See also:__ [`bind`](https://vega.github.io/vega-lite/docs/bind.html) documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ParamBind {
    Enum(LegendBinding),
    UnionMap(HashMap<String, PurpleStream>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LegendBinding {
    Legend,
    Scales,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum PurpleStream {
    AnythingArray(Vec<Option<serde_json::Value>>),
    Double(f64),
    PurpleBinding(PurpleBinding),
    String(String),
}

/// Binds the parameter to an external input element such as a slider, selection list or
/// radio button group.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleBinding {
    /// If defined, delays event handling until the specified milliseconds have elapsed since the
    /// last event was fired.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub debounce: Option<f64>,
    /// An optional CSS selector string indicating the parent element to which the input element
    /// should be added. By default, all input elements are added within the parent container of
    /// the Vega view.
    ///
    /// An input element that exposes a _value_ property and supports the
    /// [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget) interface, or
    /// a CSS selector string to such an element. When the element updates and dispatches an
    /// event, the _value_ property will be used as the new, bound signal value. When the signal
    /// updates independent of the element, the _value_ property will be set to the signal value
    /// and a new event will be dispatched on the element.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub element: Option<ElementUnion>,
    /// The type of input element to use. The valid values are `"checkbox"`, `"radio"`,
    /// `"range"`, `"select"`, and any other legal [HTML form input
    /// type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub input: Option<String>,
    /// By default, the signal name is used to label input elements. This `name` property can be
    /// used instead to specify a custom label for the bound signal.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An array of label strings to represent the `options` values. If unspecified, the
    /// `options` value will be coerced to a string and used as the label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<Vec<String>>,
    /// An array of options to select from.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub options: Option<Vec<Option<serde_json::Value>>>,
    /// Sets the maximum slider value. Defaults to the larger of the signal value and `100`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max: Option<f64>,
    /// Sets the minimum slider value. Defaults to the smaller of the signal value and `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min: Option<f64>,
    /// Sets the minimum slider increment. If undefined, the step size will be automatically
    /// determined based on the `min` and `max` values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// A hint for form autofill. See the [HTML autocomplete
    /// attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete) for
    /// additional information.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub autocomplete: Option<String>,
    /// Text that appears in the form control when it has no value set.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub placeholder: Option<String>,
    /// The event (default `"input"`) to listen for to track changes on the external element.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub event: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub between: Option<Vec<Stream>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub consume: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filter: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub markname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub marktype: Option<MarkType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub source: Option<Source>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub throttle: Option<f64>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub binding_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stream: Option<Stream>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub merge: Option<Vec<Stream>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Stream {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub between: Option<Vec<Stream>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub consume: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub debounce: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filter: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub markname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub marktype: Option<MarkType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub source: Option<Source>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub throttle: Option<f64>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stream_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stream: Option<Box<Stream>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub merge: Option<Vec<Stream>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MarkType {
    Arc,
    Area,
    Group,
    Image,
    Line,
    Path,
    Rect,
    Rule,
    Shape,
    Symbol,
    Text,
    Trail,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Source {
    Scope,
    View,
    Window,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ElementUnion {
    ElementClass(ElementClass),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ElementClass {}

/// Determines the default event processing and data query for the selection. Vega-Lite
/// currently supports two selection types:
///
/// - `"point"` -- to select multiple discrete data values; the first value is selected on
/// `click` and additional values toggled on shift-click.
/// - `"interval"` -- to select a continuous range of data values on `drag`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ParamSelect {
    Enum(SelectionType),
    SelectionConfig(SelectionConfig),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SelectionConfig {
    /// Clears the selection, emptying it of all values. This property can be a [Event
    /// Stream](https://vega.github.io/vega/docs/event-streams/) or `false` to disable clear.
    ///
    /// __Default value:__ `dblclick`.
    ///
    /// __See also:__ [`clear` examples
    /// ](https://vega.github.io/vega-lite/docs/selection.html#clear) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clear: Option<ClearUnion>,
    /// An array of encoding channels. The corresponding data field values must match for a data
    /// tuple to fall within the selection.
    ///
    /// __See also:__ The [projection with `encodings` and `fields`
    /// section](https://vega.github.io/vega-lite/docs/selection.html#project) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encodings: Option<Vec<SingleDefUnitChannel>>,
    /// An array of field names whose values must match for a data tuple to fall within the
    /// selection.
    ///
    /// __See also:__ The [projection with `encodings` and `fields`
    /// section](https://vega.github.io/vega-lite/docs/selection.html#project) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fields: Option<Vec<String>>,
    /// When true, an invisible voronoi diagram is computed to accelerate discrete selection. The
    /// data value _nearest_ the mouse cursor is added to the selection.
    ///
    /// __Default value:__ `false`, which means that data values must be interacted with directly
    /// (e.g., clicked on) to be added to the selection.
    ///
    /// __See also:__ [`nearest`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#nearest) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub nearest: Option<bool>,
    /// A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
    /// selector) that triggers the selection. For interval selections, the event stream must
    /// specify a [start and
    /// end](https://vega.github.io/vega/docs/event-streams/#between-filters).
    ///
    /// __See also:__ [`on` examples](https://vega.github.io/vega-lite/docs/selection.html#on) in
    /// the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub on: Option<OnUnion>,
    /// With layered and multi-view displays, a strategy that determines how selections' data
    /// queries are resolved when applied in a filter transform, conditional encoding rule, or
    /// scale domain.
    ///
    /// One of:
    /// - `"global"` -- only one brush exists for the entire SPLOM. When the user begins to drag,
    /// any previous brushes are cleared, and a new one is constructed.
    /// - `"union"` -- each cell contains its own brush, and points are highlighted if they lie
    /// within _any_ of these individual brushes.
    /// - `"intersect"` -- each cell contains its own brush, and points are highlighted only if
    /// they fall within _all_ of these individual brushes.
    ///
    /// __Default value:__ `global`.
    ///
    /// __See also:__ [`resolve`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#resolve) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<SelectionResolution>,
    /// Controls whether data values should be toggled (inserted or removed from a point
    /// selection) or only ever inserted into point selections.
    ///
    /// One of:
    /// - `true` -- the default behavior, which corresponds to `"event.shiftKey"`.  As a result,
    /// data values are toggled when the user interacts with the shift-key pressed.
    /// - `false` -- disables toggling behaviour; the selection will only ever contain a single
    /// data value corresponding to the most recent interaction.
    /// - A [Vega expression](https://vega.github.io/vega/docs/expressions/) which is
    /// re-evaluated as the user interacts. If the expression evaluates to `true`, the data value
    /// is toggled into or out of the point selection. If the expression evaluates to `false`,
    /// the point selection is first cleared, and the data value is then inserted. For example,
    /// setting the value to the Vega expression `"true"` will toggle data values without the
    /// user pressing the shift-key.
    ///
    /// __Default value:__ `true`
    ///
    /// __See also:__ [`toggle`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#toggle) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub toggle: Option<Toggle>,
    /// Determines the default event processing and data query for the selection. Vega-Lite
    /// currently supports two selection types:
    ///
    /// - `"point"` -- to select multiple discrete data values; the first value is selected on
    /// `click` and additional values toggled on shift-click.
    /// - `"interval"` -- to select a continuous range of data values on `drag`.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub selection_config_type: Option<SelectionType>,
    /// An interval selection also adds a rectangle mark to depict the extents of the interval.
    /// The `mark` property can be used to customize the appearance of the mark.
    ///
    /// __See also:__ [`mark`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#mark) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<BrushConfig>,
    /// When truthy, allows a user to interactively move an interval selection back-and-forth.
    /// Can be `true`, `false` (to disable panning), or a [Vega event stream
    /// definition](https://vega.github.io/vega/docs/event-streams/) which must include a start
    /// and end event to trigger continuous panning. Discrete panning (e.g., pressing the
    /// left/right arrow keys) will be supported in future versions.
    ///
    /// __Default value:__ `true`, which corresponds to `[pointerdown, window:pointerup] >
    /// window:pointermove!`. This default allows users to clicks and drags within an interval
    /// selection to reposition it.
    ///
    /// __See also:__ [`translate`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#translate) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub translate: Option<Toggle>,
    /// When truthy, allows a user to interactively resize an interval selection. Can be `true`,
    /// `false` (to disable zooming), or a [Vega event stream
    /// definition](https://vega.github.io/vega/docs/event-streams/). Currently, only `wheel`
    /// events are supported, but custom event streams can still be used to specify filters,
    /// debouncing, and throttling. Future versions will expand the set of events that can
    /// trigger this transformation.
    ///
    /// __Default value:__ `true`, which corresponds to `wheel!`. This default allows users to
    /// use the mouse wheel to resize an interval selection.
    ///
    /// __See also:__ [`zoom`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#zoom) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zoom: Option<Toggle>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ClearUnion {
    Bool(bool),
    ClearDerivedStream(ClearDerivedStream),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ClearDerivedStream {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub between: Option<Vec<Stream>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub consume: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub debounce: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filter: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub markname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub marktype: Option<MarkType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub source: Option<Source>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub throttle: Option<f64>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ed_stream_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stream: Option<Stream>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub merge: Option<Vec<Stream>>,
}

/// An interval selection also adds a rectangle mark to depict the extents of the interval.
/// The `mark` property can be used to customize the appearance of the mark.
///
/// __See also:__ [`mark`
/// examples](https://vega.github.io/vega-lite/docs/selection.html#mark) in the documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BrushConfig {
    /// The mouse cursor used over the interval mark. Any valid [CSS cursor
    /// type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<Cursor>,
    /// The fill color of the interval mark.
    ///
    /// __Default value:__ `"#333333"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<String>,
    /// The fill opacity of the interval mark (a value between `0` and `1`).
    ///
    /// __Default value:__ `0.125`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<f64>,
    /// The stroke color of the interval mark.
    ///
    /// __Default value:__ `"#ffffff"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<String>,
    /// An array of alternating stroke and space lengths, for creating dashed or dotted lines.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<Vec<f64>>,
    /// The offset (in pixels) with which to begin drawing the stroke dash array.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<f64>,
    /// The stroke opacity of the interval mark (a value between `0` and `1`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<f64>,
    /// The stroke width of the interval mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum OnUnion {
    OnDerivedStream(OnDerivedStream),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct OnDerivedStream {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub between: Option<Vec<Stream>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub consume: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub debounce: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filter: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub markname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub marktype: Option<MarkType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub source: Option<Source>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub throttle: Option<f64>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ed_stream_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stream: Option<Stream>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub merge: Option<Vec<Stream>>,
}

/// With layered and multi-view displays, a strategy that determines how selections' data
/// queries are resolved when applied in a filter transform, conditional encoding rule, or
/// scale domain.
///
/// One of:
/// - `"global"` -- only one brush exists for the entire SPLOM. When the user begins to drag,
/// any previous brushes are cleared, and a new one is constructed.
/// - `"union"` -- each cell contains its own brush, and points are highlighted if they lie
/// within _any_ of these individual brushes.
/// - `"intersect"` -- each cell contains its own brush, and points are highlighted only if
/// they fall within _all_ of these individual brushes.
///
/// __Default value:__ `global`.
///
/// __See also:__ [`resolve`
/// examples](https://vega.github.io/vega-lite/docs/selection.html#resolve) in the
/// documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SelectionResolution {
    Global,
    Intersect,
    Union,
}

/// Determines the default event processing and data query for the selection. Vega-Lite
/// currently supports two selection types:
///
/// - `"point"` -- to select multiple discrete data values; the first value is selected on
/// `click` and additional values toggled on shift-click.
/// - `"interval"` -- to select a continuous range of data values on `drag`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SelectionType {
    Interval,
    Point,
}

/// Controls whether data values should be toggled (inserted or removed from a point
/// selection) or only ever inserted into point selections.
///
/// One of:
/// - `true` -- the default behavior, which corresponds to `"event.shiftKey"`.  As a result,
/// data values are toggled when the user interacts with the shift-key pressed.
/// - `false` -- disables toggling behaviour; the selection will only ever contain a single
/// data value corresponding to the most recent interaction.
/// - A [Vega expression](https://vega.github.io/vega/docs/expressions/) which is
/// re-evaluated as the user interacts. If the expression evaluates to `true`, the data value
/// is toggled into or out of the point selection. If the expression evaluates to `false`,
/// the point selection is first cleared, and the data value is then inserted. For example,
/// setting the value to the Vega expression `"true"` will toggle data values without the
/// user pressing the shift-key.
///
/// __Default value:__ `true`
///
/// __See also:__ [`toggle`
/// examples](https://vega.github.io/vega-lite/docs/selection.html#toggle) in the
/// documentation.
///
/// When truthy, allows a user to interactively move an interval selection back-and-forth.
/// Can be `true`, `false` (to disable panning), or a [Vega event stream
/// definition](https://vega.github.io/vega/docs/event-streams/) which must include a start
/// and end event to trigger continuous panning. Discrete panning (e.g., pressing the
/// left/right arrow keys) will be supported in future versions.
///
/// __Default value:__ `true`, which corresponds to `[pointerdown, window:pointerup] >
/// window:pointermove!`. This default allows users to clicks and drags within an interval
/// selection to reposition it.
///
/// __See also:__ [`translate`
/// examples](https://vega.github.io/vega-lite/docs/selection.html#translate) in the
/// documentation.
///
/// When truthy, allows a user to interactively resize an interval selection. Can be `true`,
/// `false` (to disable zooming), or a [Vega event stream
/// definition](https://vega.github.io/vega/docs/event-streams/). Currently, only `wheel`
/// events are supported, but custom event streams can still be used to specify filters,
/// debouncing, and throttling. Future versions will expand the set of events that can
/// trigger this transformation.
///
/// __Default value:__ `true`, which corresponds to `wheel!`. This default allows users to
/// use the mouse wheel to resize an interval selection.
///
/// __See also:__ [`zoom`
/// examples](https://vega.github.io/vega-lite/docs/selection.html#zoom) in the documentation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Toggle {
    Bool(bool),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ParamValue {
    Bool(bool),
    Double(f64),
    String(String),
    UnionMap(HashMap<String, DateTimeValue>),
    UnionMapArray(Vec<HashMap<String, Option<SelectionInit>>>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum SelectionInit {
    Bool(bool),
    DateTime(DateTime),
    Double(f64),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DateTimeValue {
    Bool(bool),
    Double(f64),
    String(String),
    UnionArray(Vec<UnionWith>),
}

/// Projection configuration, which determines default properties for all
/// [projections](https://vega.github.io/vega-lite/docs/projection.html). For a full list of
/// projection configuration options, please see the [corresponding section of the projection
/// documentation](https://vega.github.io/vega-lite/docs/projection.html#config).
///
/// Any property of Projection can be in config
///
/// An object defining properties of geographic projection, which will be applied to `shape`
/// path for `"geoshape"` marks and to `latitude` and `"longitude"` channels for other
/// marks.
///
/// An object defining properties of the geographic projection shared by underlying layers.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Projection {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip_angle: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip_extent: Option<ClipExtentUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub coefficient: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub distance: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<ClipExtentUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fit: Option<ProjectionFit>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fraction: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub lobes: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub parallel: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub parallels: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub precision: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ratio: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub reflect_x: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub reflect_y: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rotate: Option<StrokeDashUnion>,
    /// The projection’s scale (zoom) factor, overriding automatic fitting. The default scale is
    /// projection-specific. The scale factor corresponds linearly to the distance between
    /// projected points; however, scale factor values are not equivalent across projections.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub scale: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tilt: Option<CornerRadiusUnion>,
    /// The projection’s translation offset as a two-element array `[tx, ty]`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub translate: Option<StrokeDashUnion>,
    /// The cartographic projection to use. This value is case-insensitive, for example
    /// `"albers"` and `"Albers"` indicate the same projection type. You can find all valid
    /// projection types [in the
    /// documentation](https://vega.github.io/vega-lite/docs/projection.html#projection-types).
    ///
    /// __Default value:__ `equalEarth`
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection_type: Option<TypeUnion>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ClipExtentUnion {
    BackgroundExprRef(BackgroundExprRef),
    DoubleArrayArray(Vec<Vec<f64>>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ProjectionFit {
    ExprRefClass(ExprRefClass),
    UnionArray(Vec<FitElement>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum FitElement {
    FeatureArray(Vec<Feature>),
    PurpleFeature(PurpleFeature),
}

/// A feature object which contains a geometry and associated properties.
/// https://tools.ietf.org/html/rfc7946#section-3.2
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Feature {
    /// Bounding box of the coordinate range of the object's Geometries, Features, or Feature
    /// Collections. https://tools.ietf.org/html/rfc7946#section-5
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bbox: Option<Vec<f64>>,
    /// The feature's geometry
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geometry: Option<Geometry>,
    /// A value that uniquely identifies this feature in a
    /// https://tools.ietf.org/html/rfc7946#section-3.2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<Id>,
    /// Properties associated with this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub properties: Option<HashMap<String, Option<serde_json::Value>>>,
    /// Specifies the type of GeoJSON object.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub feature_type: Option<FitType>,
}

/// Specifies the type of GeoJSON object.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FitType {
    Feature,
}

/// The feature's geometry
///
/// Union of geometry objects. https://tools.ietf.org/html/rfc7946#section-3
///
/// Point geometry object. https://tools.ietf.org/html/rfc7946#section-3.1.2
///
/// MultiPoint geometry object.  https://tools.ietf.org/html/rfc7946#section-3.1.3
///
/// LineString geometry object. https://tools.ietf.org/html/rfc7946#section-3.1.4
///
/// MultiLineString geometry object. https://tools.ietf.org/html/rfc7946#section-3.1.5
///
/// Polygon geometry object. https://tools.ietf.org/html/rfc7946#section-3.1.6
///
/// MultiPolygon geometry object. https://tools.ietf.org/html/rfc7946#section-3.1.7
///
/// Geometry Collection https://tools.ietf.org/html/rfc7946#section-3.1.8
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Geometry {
    /// Bounding box of the coordinate range of the object's Geometries, Features, or Feature
    /// Collections. https://tools.ietf.org/html/rfc7946#section-5
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bbox: Option<Vec<f64>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub coordinates: Option<Vec<Coordinate>>,
    /// Specifies the type of GeoJSON object.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geometry_type: Option<GeometryType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geometries: Option<Vec<Geometry>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Coordinate {
    Double(f64),
    UnionArray(Vec<CoordinateVector2Number>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum CoordinateVector2Number {
    Double(f64),
    UnionArray(Vec<Vector2NumberVector2Number>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Vector2NumberVector2Number {
    Double(f64),
    DoubleArray(Vec<f64>),
}

/// Specifies the type of GeoJSON object.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum GeometryType {
    #[serde(rename = "GeometryCollection")]
    GeometryCollection,
    #[serde(rename = "LineString")]
    LineString,
    #[serde(rename = "MultiLineString")]
    MultiLineString,
    #[serde(rename = "MultiPoint")]
    MultiPoint,
    #[serde(rename = "MultiPolygon")]
    MultiPolygon,
    Point,
    Polygon,
}

/// A value that uniquely identifies this feature in a
/// https://tools.ietf.org/html/rfc7946#section-3.2.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Id {
    Double(f64),
    String(String),
}

/// A feature object which contains a geometry and associated properties.
/// https://tools.ietf.org/html/rfc7946#section-3.2
///
/// A collection of feature objects.  https://tools.ietf.org/html/rfc7946#section-3.3
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleFeature {
    /// Bounding box of the coordinate range of the object's Geometries, Features, or Feature
    /// Collections. https://tools.ietf.org/html/rfc7946#section-5
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bbox: Option<Vec<f64>>,
    /// The feature's geometry
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geometry: Option<Geometry>,
    /// A value that uniquely identifies this feature in a
    /// https://tools.ietf.org/html/rfc7946#section-3.2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<Id>,
    /// Properties associated with this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub properties: Option<HashMap<String, Option<serde_json::Value>>>,
    /// Specifies the type of GeoJSON object.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub feature_type: Option<FeatureType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub features: Option<Vec<FeatureGeometryGeoJsonProperties>>,
}

/// Specifies the type of GeoJSON object.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FeatureType {
    Feature,
    #[serde(rename = "FeatureCollection")]
    FeatureCollection,
}

/// A feature object which contains a geometry and associated properties.
/// https://tools.ietf.org/html/rfc7946#section-3.2
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FeatureGeometryGeoJsonProperties {
    /// Bounding box of the coordinate range of the object's Geometries, Features, or Feature
    /// Collections. https://tools.ietf.org/html/rfc7946#section-5
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bbox: Option<Vec<f64>>,
    /// The feature's geometry
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geometry: Option<Geometry>,
    /// A value that uniquely identifies this feature in a
    /// https://tools.ietf.org/html/rfc7946#section-3.2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<Id>,
    /// Properties associated with this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub properties: Option<HashMap<String, Option<serde_json::Value>>>,
    /// Specifies the type of GeoJSON object.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub feature_geometry_geo_json_properties_type: Option<FitType>,
}

/// A feature object which contains a geometry and associated properties.
/// https://tools.ietf.org/html/rfc7946#section-3.2
///
/// A collection of feature objects.  https://tools.ietf.org/html/rfc7946#section-3.3
///
/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ExprRefClass {
    /// Bounding box of the coordinate range of the object's Geometries, Features, or Feature
    /// Collections. https://tools.ietf.org/html/rfc7946#section-5
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bbox: Option<Vec<f64>>,
    /// The feature's geometry
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geometry: Option<Geometry>,
    /// A value that uniquely identifies this feature in a
    /// https://tools.ietf.org/html/rfc7946#section-3.2.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<Id>,
    /// Properties associated with this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub properties: Option<HashMap<String, Option<serde_json::Value>>>,
    /// Specifies the type of GeoJSON object.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub feature_type: Option<FeatureType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub features: Option<Vec<FeatureGeometryGeoJsonProperties>>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

/// The cartographic projection to use. This value is case-insensitive, for example
/// `"albers"` and `"Albers"` indicate the same projection type. You can find all valid
/// projection types [in the
/// documentation](https://vega.github.io/vega-lite/docs/projection.html#projection-types).
///
/// __Default value:__ `equalEarth`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TypeUnion {
    BackgroundExprRef(BackgroundExprRef),
    Enum(ProjectionType),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum ProjectionType {
    Albers,
    #[serde(rename = "albersUsa")]
    AlbersUsa,
    #[serde(rename = "azimuthalEqualArea")]
    AzimuthalEqualArea,
    #[serde(rename = "azimuthalEquidistant")]
    AzimuthalEquidistant,
    #[serde(rename = "conicConformal")]
    ConicConformal,
    #[serde(rename = "conicEqualArea")]
    ConicEqualArea,
    #[serde(rename = "conicEquidistant")]
    ConicEquidistant,
    #[serde(rename = "equalEarth")]
    EqualEarth,
    Equirectangular,
    Gnomonic,
    Identity,
    Mercator,
    #[serde(rename = "naturalEarth1")]
    NaturalEarth1,
    Orthographic,
    Stereographic,
    #[serde(rename = "transverseMercator")]
    TransverseMercator,
}

/// Scale, axis, and legend resolutions for view composition specifications.
///
/// Defines how scales, axes, and legends from different specs should be combined. Resolve is
/// a mapping from `scale`, `axis`, and `legend` to a mapping from channels to resolutions.
/// Scales and guides can be resolved to be `"independent"` or `"shared"`.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Resolve {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis: Option<AxisResolveMap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend: Option<LegendResolveMap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub scale: Option<ScaleResolveMap>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AxisResolveMap {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<ResolveMode>,
}

/// Indicates how parameters for multiple densities should be resolved. If `"independent"`,
/// each density may have its own domain extent and dynamic number of curve sample steps. If
/// `"shared"`, the KDE transform will ensure that all densities are defined over a shared
/// domain and curve steps, enabling stacking.
///
/// __Default value:__ `"shared"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ResolveMode {
    Independent,
    Shared,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LegendResolveMap {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<ResolveMode>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleResolveMap {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<ResolveMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<ResolveMode>,
}

/// Title for the plot.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TitleUnion {
    String(String),
    StringArray(Vec<String>),
    TitleParams(Box<TitleParams>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TitleParams {
    /// Horizontal text alignment for title text. One of `"left"`, `"center"`, or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Align>,
    /// The anchor position for placing the title. One of `"start"`, `"middle"`, or `"end"`. For
    /// example, with an orientation of top these anchor positions map to a left-, center-, or
    /// right-aligned title.
    ///
    /// __Default value:__ `"middle"` for
    /// [single](https://vega.github.io/vega-lite/docs/spec.html) and
    /// [layered](https://vega.github.io/vega-lite/docs/layer.html) views. `"start"` for other
    /// composite views.
    ///
    /// __Note:__ [For now](https://github.com/vega/vega-lite/issues/2875), `anchor` is only
    /// customizable only for [single](https://vega.github.io/vega-lite/docs/spec.html) and
    /// [layered](https://vega.github.io/vega-lite/docs/layer.html) views. For other composite
    /// views, `anchor` is always `"start"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub anchor: Option<TitleAnchorEnum>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    /// Vertical text baseline for title and subtitle text. One of `"alphabetic"` (default),
    /// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
    /// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
    /// relative to the *lineHeight* rather than *fontSize* alone.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<Baseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub frame: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<TitleParamsOrient>,
    /// A [mark style property](https://vega.github.io/vega-lite/docs/config.html#style) to apply
    /// to the title text mark.
    ///
    /// __Default value:__ `"group-title"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
    /// The subtitle Text.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_padding: Option<CornerRadiusUnion>,
    /// The title text.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalValueDefTextExprRefText>,
    /// The integer z-index indicating the layering of the title group relative to other axis,
    /// mark and legend groups.
    ///
    /// __Default value:__ `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TitleParamsOrient {
    BackgroundExprRef(BackgroundExprRef),
    Enum(TitleOrient),
}

/// Default title orientation (`"top"`, `"bottom"`, `"left"`, or `"right"`)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TitleOrient {
    Bottom,
    Left,
    None,
    Right,
    Top,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Transform {
    /// Array of objects that define fields to aggregate.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregate: Option<Vec<AggregatedFieldDef>>,
    /// The data fields to group by. If not specified, a single group containing all data objects
    /// will be used.
    ///
    /// An optional array of fields by which to group the values. Imputation will then be
    /// performed on a per-group basis.
    ///
    /// The data fields for partitioning the data objects into separate groups. If unspecified,
    /// all data points will be in a single group.
    ///
    /// The data fields to group by.
    ///
    /// The data fields for partitioning the data objects into separate windows. If unspecified,
    /// all data points will be in a single window.
    ///
    /// The optional data fields to group by. If not specified, a single group containing all
    /// data objects will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub groupby: Option<Vec<String>>,
    /// The output fields at which to write the start and end bin values. This can be either a
    /// string or an array of strings with two elements denoting the name for the fields for bin
    /// start and bin end respectively. If a single string (e.g., `"val"`) is provided, the end
    /// field will be `"val_end"`.
    ///
    /// The field for storing the computed formula value.
    ///
    /// The output fields for the sample value and corresponding density estimate.
    ///
    /// __Default value:__ `["value", "density"]`
    ///
    /// The output field names for extracted array values.
    ///
    /// __Default value:__ The field name of the corresponding array field
    ///
    /// The output field names for the key and value properties produced by the fold transform.
    /// __Default value:__ `["key", "value"]`
    ///
    /// The output field names for the smoothed points generated by the loess transform.
    ///
    /// __Default value:__ The field names of the input x and y values.
    ///
    /// The output fields on which to store the looked up data values.
    ///
    /// For data lookups, this property may be left blank if `from.fields` has been specified
    /// (those field names will be used); if `from.fields` has not been specified, `as` must be a
    /// string.
    ///
    /// For selection lookups, this property is optional: if unspecified, looked up values will
    /// be stored under a property named for the selection; and if specified, it must correspond
    /// to `from.fields`.
    ///
    /// The output field names for the probability and quantile values.
    ///
    /// __Default value:__ `["prob", "value"]`
    ///
    /// The output field names for the smoothed points generated by the regression transform.
    ///
    /// __Default value:__ The field names of the input x and y values.
    ///
    /// The output field to write the timeUnit value.
    ///
    /// Output field names. This can be either a string or an array of strings with two elements
    /// denoting the name for the fields for stack start and stack end respectively. If a single
    /// string(e.g., `"val"`) is provided, the end field will be `"val_end"`.
    #[serde(rename = "as")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform_as: Option<LegendText>,
    /// An object indicating bin properties, or simply `true` for using default bin parameters.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin: Option<AngleBin>,
    /// The data field to bin.
    ///
    /// The data field to apply time unit.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// A [expression](https://vega.github.io/vega-lite/docs/types.html#expression) string. Use
    /// the variable `datum` to refer to the current data object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub calculate: Option<String>,
    /// The bandwidth (standard deviation) of the Gaussian kernel. If unspecified or set to zero,
    /// the bandwidth value is automatically estimated from the input data using Scott’s rule.
    ///
    /// A bandwidth parameter in the range `[0, 1]` that determines the amount of smoothing.
    ///
    /// __Default value:__ `0.3`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bandwidth: Option<f64>,
    /// A boolean flag indicating if the output values should be probability estimates (false) or
    /// smoothed counts (true).
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub counts: Option<bool>,
    /// A boolean flag indicating whether to produce density estimates (false) or cumulative
    /// density estimates (true).
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cumulative: Option<bool>,
    /// The data field for which to perform density estimation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub density: Option<String>,
    /// A [min, max] domain from which to sample the distribution. If unspecified, the extent
    /// will be determined by the observed minimum and maximum values of the density value
    /// field.
    ///
    /// The field of which to get the extent.
    ///
    /// A [min, max] domain over the independent (x) field for the starting and ending points of
    /// the generated trend line.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<TransformExtent>,
    /// The maximum number of samples to take along the extent domain for plotting the density.
    ///
    /// __Default value:__ `200`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub maxsteps: Option<f64>,
    /// The minimum number of samples to take along the extent domain for plotting the density.
    ///
    /// __Default value:__ `25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minsteps: Option<f64>,
    /// Indicates how parameters for multiple densities should be resolved. If `"independent"`,
    /// each density may have its own domain extent and dynamic number of curve sample steps. If
    /// `"shared"`, the KDE transform will ensure that all densities are defined over a shared
    /// domain and curve steps, enabling stacking.
    ///
    /// __Default value:__ `"shared"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<ResolveMode>,
    /// The exact number of samples to take along the extent domain for plotting the density. If
    /// specified, overrides both minsteps and maxsteps to set an exact number of uniform
    /// samples. Potentially useful in conjunction with a fixed extent to ensure consistent
    /// sample points for stacked densities.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub steps: Option<f64>,
    /// The output parameter produced by the extent transform.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
    /// The `filter` property must be a predication definition, which can take one of the
    /// following forms:
    ///
    /// 1) an [expression](https://vega.github.io/vega-lite/docs/types.html#expression) string,
    /// where `datum` can be used to refer to the current data object. For example, `{filter:
    /// "datum.b2 > 60"}` would make the output data includes only items that have values in the
    /// field `b2` over 60.
    ///
    /// 2) one of the [field
    /// predicates](https://vega.github.io/vega-lite/docs/predicate.html#field-predicate):
    /// [`equal`](https://vega.github.io/vega-lite/docs/predicate.html#field-equal-predicate),
    /// [`lt`](https://vega.github.io/vega-lite/docs/predicate.html#lt-predicate),
    /// [`lte`](https://vega.github.io/vega-lite/docs/predicate.html#lte-predicate),
    /// [`gt`](https://vega.github.io/vega-lite/docs/predicate.html#gt-predicate),
    /// [`gte`](https://vega.github.io/vega-lite/docs/predicate.html#gte-predicate),
    /// [`range`](https://vega.github.io/vega-lite/docs/predicate.html#range-predicate),
    /// [`oneOf`](https://vega.github.io/vega-lite/docs/predicate.html#one-of-predicate), or
    /// [`valid`](https://vega.github.io/vega-lite/docs/predicate.html#valid-predicate),
    ///
    /// 3) a [selection
    /// predicate](https://vega.github.io/vega-lite/docs/predicate.html#selection-predicate),
    /// which define the names of a selection that the data point should belong to (or a logical
    /// composition of selections).
    ///
    /// 4) a [logical
    /// composition](https://vega.github.io/vega-lite/docs/predicate.html#composition) of (1),
    /// (2), or (3).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filter: Option<ConditionalValueDefNumberExprRefPredicateComposition>,
    /// An array of one or more data fields containing arrays to flatten. If multiple fields are
    /// specified, their array values should have a parallel structure, ideally with the same
    /// length. If the lengths of parallel arrays do not match, the longest array will be used
    /// with `null` values added for missing entries.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub flatten: Option<Vec<String>>,
    /// An array of data fields indicating the properties to fold.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fold: Option<Vec<String>>,
    /// A frame specification as a two-element array used to control the window over which the
    /// specified method is applied. The array entries should either be a number indicating the
    /// offset from the current data object, or null to indicate unbounded rows preceding or
    /// following the current data object. For example, the value `[-5, 5]` indicates that the
    /// window should include five objects preceding and five objects following the current
    /// object.
    ///
    /// __Default value:__:  `[null, null]` indicating that the window includes all objects.
    ///
    /// A frame specification as a two-element array indicating how the sliding window should
    /// proceed. The array entries should either be a number indicating the offset from the
    /// current data object, or null to indicate unbounded rows preceding or following the
    /// current data object. The default value is `[null, 0]`, indicating that the sliding window
    /// includes the current object and all preceding objects. The value `[-5, 5]` indicates that
    /// the window should include five objects preceding and five objects following the current
    /// object. Finally, `[null, null]` indicates that the window frame should always include all
    /// data objects. If you this frame and want to assign the same value to add objects, you can
    /// use the simpler [join aggregate
    /// transform](https://vega.github.io/vega-lite/docs/joinaggregate.html). The only operators
    /// affected are the aggregation operations and the `first_value`, `last_value`, and
    /// `nth_value` window operations. The other window operations are not affected by this.
    ///
    /// __Default value:__:  `[null, 0]` (includes the current object and all preceding objects)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub frame: Option<Vec<Option<f64>>>,
    /// The data field for which the missing values should be imputed.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub impute: Option<String>,
    /// A key field that uniquely identifies data objects within a group. Missing key values
    /// (those occurring in the data but not in the current group) will be imputed.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub key: Option<String>,
    /// Defines the key values that should be considered for imputation. An array of key values
    /// or an object defining a [number
    /// sequence](https://vega.github.io/vega-lite/docs/impute.html#sequence-def).
    ///
    /// If provided, this will be used in addition to the key values observed within the input
    /// data. If not provided, the values will be derived from all unique values of the `key`
    /// field. For `impute` in `encoding`, the key field is the x-field if the y-field is
    /// imputed, or vice versa.
    ///
    /// If there is no impute grouping, this property _must_ be specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub keyvals: Option<Keyvals>,
    /// The imputation method to use for the field value of imputed data objects. One of
    /// `"value"`, `"mean"`, `"median"`, `"max"` or `"min"`.
    ///
    /// __Default value:__  `"value"`
    ///
    /// The functional form of the regression model. One of `"linear"`, `"log"`, `"exp"`,
    /// `"pow"`, `"quad"`, or `"poly"`.
    ///
    /// __Default value:__ `"linear"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub method: Option<TransformMethod>,
    /// The field value to use when the imputation `method` is `"value"`.
    ///
    /// The data field to populate pivoted fields. The aggregate values of this field become the
    /// values of the new pivoted fields.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<serde_json::Value>,
    /// The definition of the fields in the join aggregate, and what calculations to use.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub joinaggregate: Option<Vec<JoinAggregateFieldDef>>,
    /// The data field of the dependent variable to smooth.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub loess: Option<String>,
    /// The data field of the independent variable to use a predictor.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub on: Option<String>,
    /// The default value to use if lookup fails.
    ///
    /// __Default value:__ `null`
    #[serde(rename = "default")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform_default: Option<serde_json::Value>,
    /// Data source or selection for secondary data reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub from: Option<Lookup>,
    /// Key in primary data source.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub lookup: Option<String>,
    /// An array of probabilities in the range (0, 1) for which to compute quantile values. If
    /// not specified, the *step* parameter will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub probs: Option<Vec<f64>>,
    /// The data field for which to perform quantile estimation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quantile: Option<String>,
    /// A probability step size (default 0.01) for sampling quantile values. All values from
    /// one-half the step size up to 1 (exclusive) will be sampled. This parameter is only used
    /// if the *probs* parameter is not provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// The polynomial order (number of coefficients) for the 'poly' method.
    ///
    /// __Default value:__ `3`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<f64>,
    /// A boolean flag indicating if the transform should return the regression model parameters
    /// (one object per group), rather than trend line points. The resulting objects include a
    /// `coef` array of fitted coefficient values (starting with the intercept term and then
    /// including terms of increasing order) and an `rSquared` value (indicating the total
    /// variance explained by the model).
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<bool>,
    /// The data field of the dependent variable to predict.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub regression: Option<String>,
    /// The timeUnit.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit: Option<TransformTimeUnit>,
    /// The maximum number of data objects to include in the sample.
    ///
    /// __Default value:__ `1000`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sample: Option<f64>,
    /// Mode for stacking marks. One of `"zero"` (default), `"center"`, or `"normalize"`. The
    /// `"zero"` offset will stack starting at `0`. The `"center"` offset will center the stacks.
    /// The `"normalize"` offset will compute percentage values for each stack point, with output
    /// values in the range `[0,1]`.
    ///
    /// __Default value:__ `"zero"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<StackOffset>,
    /// Field that determines the order of leaves in the stacked charts.
    ///
    /// A sort field definition for sorting data objects within a window. If two data objects are
    /// considered equal by the comparator, they are considered "peer" values of equal rank. If
    /// sort is not specified, the order is undefined: data objects are processed in the order
    /// they are observed and none are considered peers (the ignorePeers parameter is ignored and
    /// treated as if set to `true`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sort: Option<Vec<SortField>>,
    /// The field which is stacked.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stack: Option<String>,
    /// Indicates if the sliding window frame should ignore peer values (data that are considered
    /// identical by the sort criteria). The default is false, causing the window frame to expand
    /// to include all peer values. If set to true, the window frame will be defined by offset
    /// values only. This setting only affects those operations that depend on the window frame,
    /// namely aggregation operations and the first_value, last_value, and nth_value window
    /// operations.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ignore_peers: Option<bool>,
    /// The definition of the fields in the window, and what calculations to use.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub window: Option<Vec<WindowFieldDef>>,
    /// An optional parameter indicating the maximum number of pivoted fields to generate. The
    /// default (`0`) applies no limit. The pivoted `pivot` names are sorted in ascending order
    /// prior to enforcing the limit. __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<f64>,
    /// The aggregation operation to apply to grouped `value` field values. __Default value:__
    /// `sum`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub op: Option<AggregateOp>,
    /// The data field to pivot on. The unique values of this field become new field names in the
    /// output stream.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pivot: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AggregatedFieldDef {
    /// The output field names to use for each aggregated field.
    #[serde(rename = "as")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aggregated_field_def_as: Option<String>,
    /// The data field for which to compute aggregate function. This is required for all
    /// aggregation operations except `"count"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// The aggregation operation to apply to the fields (e.g., `"sum"`, `"average"`, or
    /// `"count"`). See the [full list of supported aggregation
    /// operations](https://vega.github.io/vega-lite/docs/aggregate.html#ops) for more
    /// information.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub op: Option<AggregateOp>,
}

/// The aggregation operation to apply to the fields (e.g., `"sum"`, `"average"`, or
/// `"count"`). See the [full list of supported aggregation
/// operations](https://vega.github.io/vega-lite/docs/aggregate.html#ops) for more
/// information.
///
/// The aggregation operation to apply (e.g., `"sum"`, `"average"` or `"count"`). See the
/// list of all supported operations
/// [here](https://vega.github.io/vega-lite/docs/aggregate.html#ops).
///
/// The aggregation operation to apply to grouped `value` field values. __Default value:__
/// `sum`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AggregateOp {
    Argmax,
    Argmin,
    Average,
    Ci0,
    Ci1,
    Count,
    Distinct,
    Exponential,
    Exponentialb,
    Max,
    Mean,
    Median,
    Min,
    Missing,
    Product,
    Q1,
    Q3,
    Stderr,
    Stdev,
    Stdevp,
    Sum,
    Valid,
    Values,
    Variance,
    Variancep,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TransformExtent {
    DoubleArray(Vec<f64>),
    String(String),
}

/// Data source or selection for secondary data reference.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Lookup {
    /// Secondary data source to lookup in.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub data: Option<Data>,
    /// Fields in foreign data or selection to lookup. If not specified, the entire object is
    /// queried.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fields: Option<Vec<String>>,
    /// Key in data to lookup.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub key: Option<String>,
    /// Selection parameter name to look up.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<String>,
}

/// Secondary data source to lookup in.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Data {
    /// An object that specifies the format for parsing the data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<DataFormat>,
    /// Provide a placeholder name and bind data at runtime.
    ///
    /// Provide a placeholder name and bind data at runtime.
    ///
    /// New data may change the layout but Vega does not always resize the chart. To update the
    /// layout when the data updates, set
    /// [autosize](https://vega.github.io/vega-lite/docs/size.html#autosize) or explicitly use
    /// [view.resize](https://vega.github.io/vega/docs/api/view/#view_resize).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An URL from which to load the data set. Use the `format.type` property to ensure the
    /// loaded data is correctly parsed.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<String>,
    /// The full data set, included inline. This can be an array of objects or primitive values,
    /// an object, or a string. Arrays of primitive values are ingested as objects with a `data`
    /// property. Strings are parsed according to the specified format type.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub values: Option<UrlDataInlineDataset>,
    /// Generate a sequence of numbers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sequence: Option<SequenceParams>,
    /// Generate sphere GeoJSON data for the full globe.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub sphere: Option<SphereUnion>,
    /// Generate graticule GeoJSON data for geographic reference lines.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub graticule: Option<Graticule>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct JoinAggregateFieldDef {
    /// The output name for the join aggregate operation.
    #[serde(rename = "as")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub join_aggregate_field_def_as: Option<String>,
    /// The data field for which to compute the aggregate function. This can be omitted for
    /// functions that do not operate over a field such as `"count"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// The aggregation operation to apply (e.g., `"sum"`, `"average"` or `"count"`). See the
    /// list of all supported operations
    /// [here](https://vega.github.io/vega-lite/docs/aggregate.html#ops).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub op: Option<AggregateOp>,
}

/// The imputation method to use for the field value of imputed data objects. One of
/// `"value"`, `"mean"`, `"median"`, `"max"` or `"min"`.
///
/// __Default value:__  `"value"`
///
/// The functional form of the regression model. One of `"linear"`, `"log"`, `"exp"`,
/// `"pow"`, `"quad"`, or `"poly"`.
///
/// __Default value:__ `"linear"`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TransformMethod {
    Exp,
    Linear,
    Log,
    Max,
    Mean,
    Median,
    Min,
    Poly,
    Pow,
    Quad,
    Value,
}

/// A sort definition for transform
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SortField {
    /// The name of the field to sort.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// Whether to sort the field in ascending or descending order. One of `"ascending"`
    /// (default), `"descending"`, or `null` (no not sort).
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub order: RemovableValue<SortOrder>,
}

/// The timeUnit.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TransformTimeUnit {
    Enum(TimeUnit),
    TimeUnitTransformParams(TimeUnitTransformParams),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TimeUnitTransformParams {
    /// If no `unit` is specified, maxbins is used to infer time units.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub maxbins: Option<f64>,
    /// The number of steps between bins, in terms of the least significant unit provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// Defines how date-time values should be binned.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub unit: Option<TimeUnit>,
    /// True to use UTC timezone. Equivalent to using a `utc` prefixed `TimeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub utc: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct WindowFieldDef {
    /// The output name for the window operation.
    #[serde(rename = "as")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub window_field_def_as: Option<String>,
    /// The data field for which to compute the aggregate or window function. This can be omitted
    /// for window functions that do not operate over a field such as `"count"`, `"rank"`,
    /// `"dense_rank"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field: Option<String>,
    /// The window or aggregation operation to apply within a window (e.g., `"rank"`, `"lead"`,
    /// `"sum"`, `"average"` or `"count"`). See the list of all supported operations
    /// [here](https://vega.github.io/vega-lite/docs/window.html#ops).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub op: Option<Op>,
    /// Parameter values for the window functions. Parameter values can be omitted for operations
    /// that do not accept a parameter.
    ///
    /// See the list of all supported operations and their parameters
    /// [here](https://vega.github.io/vega-lite/docs/transforms/window.html).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub param: Option<f64>,
}

/// The window or aggregation operation to apply within a window (e.g., `"rank"`, `"lead"`,
/// `"sum"`, `"average"` or `"count"`). See the list of all supported operations
/// [here](https://vega.github.io/vega-lite/docs/window.html#ops).
///
/// The aggregation operation to apply to the fields (e.g., `"sum"`, `"average"`, or
/// `"count"`). See the [full list of supported aggregation
/// operations](https://vega.github.io/vega-lite/docs/aggregate.html#ops) for more
/// information.
///
/// The aggregation operation to apply (e.g., `"sum"`, `"average"` or `"count"`). See the
/// list of all supported operations
/// [here](https://vega.github.io/vega-lite/docs/aggregate.html#ops).
///
/// The aggregation operation to apply to grouped `value` field values. __Default value:__
/// `sum`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Op {
    Argmax,
    Argmin,
    Average,
    Ci0,
    Ci1,
    Count,
    #[serde(rename = "cume_dist")]
    CumeDist,
    #[serde(rename = "dense_rank")]
    DenseRank,
    Distinct,
    Exponential,
    Exponentialb,
    #[serde(rename = "first_value")]
    FirstValue,
    Lag,
    #[serde(rename = "last_value")]
    LastValue,
    Lead,
    Max,
    Mean,
    Median,
    Min,
    Missing,
    #[serde(rename = "nth_value")]
    NthValue,
    Ntile,
    #[serde(rename = "percent_rank")]
    PercentRank,
    Product,
    Q1,
    Q3,
    Rank,
    #[serde(rename = "row_number")]
    RowNumber,
    Stderr,
    Stdev,
    Stdevp,
    Sum,
    Valid,
    Values,
    Variance,
    Variancep,
}

/// An object defining the view background's fill and stroke.
///
/// __Default value:__ none (transparent)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ViewBackground {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    /// The mouse cursor used over the view. Any valid [CSS cursor
    /// type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<Cursor>,
    /// The fill color.
    ///
    /// __Default value:__ `undefined`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// The stroke color.
    ///
    /// __Default value:__ `"#ddd"`
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub stroke: RemovableValue<Color>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    /// A string or array of strings indicating the name of custom styles to apply to the view
    /// background. A style is a named collection of mark property defaults defined within the
    /// [style configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If
    /// style is an array, later styles will override earlier styles.
    ///
    /// __Default value:__ `"cell"` __Note:__ Any specified view background properties will
    /// augment the default style.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum RepeatUnion {
    RepeatMapping(RepeatMapping),
    StringArray(Vec<String>),
}

/// Definition for fields to be repeated. One of: 1) An array of fields to be repeated. If
/// `"repeat"` is an array, the field can be referred to as `{"repeat": "repeat"}`. The
/// repeated views are laid out in a wrapped row. You can set the number of columns to
/// control the wrapping. 2) An object that maps `"row"` and/or `"column"` to the listed
/// fields to be repeated along the particular orientations. The objects `{"repeat": "row"}`
/// and `{"repeat": "column"}` can be used to refer to the repeated field respectively.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RepeatMapping {
    /// An array of fields to be repeated horizontally.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<Vec<String>>,
    /// An array of fields to be repeated vertically.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<Vec<String>>,
    /// An array of fields to be repeated as layers.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layer: Option<Vec<String>>,
}

/// A key-value mapping between encoding channels and definition of fields.
///
/// A shared key-value mapping between encoding channels and definition of fields in the
/// underlying layers.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct EdEncoding {
    /// Rotation angle of point and text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<AngleClass>,
    /// Color of the marks – either fill or stroke color based on  the `filled` property of mark
    /// definition. By default, `color` represents fill color for `"area"`, `"bar"`, `"tick"`,
    /// `"text"`, `"trail"`, `"circle"`, and `"square"` / stroke color for `"line"` and
    /// `"point"`.
    ///
    /// __Default value:__ If undefined, the default color depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ 1) For fine-grained control over both fill and stroke colors of the marks, please
    /// use the `fill` and `stroke` channels. The `fill` or `stroke` encodings have higher
    /// precedence than `color`, thus may override the `color` encoding if conflicting encodings
    /// are specified. 2) See the scale documentation for more information about customizing
    /// [color scheme](https://vega.github.io/vega-lite/docs/scale.html#scheme).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<ColorClass>,
    /// A field definition for the horizontal facet of trellis plots.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column: Option<RowColumnEncodingFieldDef>,
    /// A text description of this mark for ARIA accessibility (SVG output only). For SVG output
    /// the `"aria-label"` attribute will be set to this description.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<DescriptionClass>,
    /// Additional levels of detail for grouping data in aggregate views and in line, trail, and
    /// area marks without mapping data to a specific visual channel.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub detail: Option<Detail>,
    /// A field definition for the (flexible) facet of trellis plots.
    ///
    /// If either `row` or `column` is specified, this channel will be ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<FacetEncodingFieldDef>,
    /// Fill color of the marks. __Default value:__ If undefined, the default color depends on
    /// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ The `fill` encoding has higher precedence than `color`, thus may override the
    /// `color` encoding if conflicting encodings are specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<FillClass>,
    /// Fill opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `fillOpacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<FillOpacityClass>,
    /// A URL to load upon mouse click.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<HrefClass>,
    /// A data field to use as a unique key for data binding. When a visualization’s data is
    /// updated, the key value will be used to match data elements to existing mark instances.
    /// Use a key channel to enable object constancy for transitions over dynamic data.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub key: Option<KeyClass>,
    /// Latitude position of geographically projected marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub latitude: Option<LatitudeClass>,
    /// Latitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`, and
    /// `"rule"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub latitude2: Option<Latitude2Class>,
    /// Longitude position of geographically projected marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub longitude: Option<LongitudeClass>,
    /// Longitude-2 position for geographically projected ranged `"area"`, `"bar"`, `"rect"`,
    /// and  `"rule"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub longitude2: Option<Longitude2Class>,
    /// Opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `opacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<OpacityClass>,
    /// Order of the marks.
    /// - For stacked marks, this `order` channel encodes [stack
    /// order](https://vega.github.io/vega-lite/docs/stack.html#order).
    /// - For line and trail marks, this `order` channel encodes order of data points in the
    /// lines. This can be useful for creating [a connected
    /// scatterplot](https://vega.github.io/vega-lite/examples/connected_scatterplot.html).
    /// Setting `order` to `{"value": null}` makes the line marks use the original order in the
    /// data sources.
    /// - Otherwise, this `order` channel encodes layer order of the marks.
    ///
    /// __Note__: In aggregate plots, `order` field should be `aggregate`d to avoid creating
    /// additional aggregation grouping.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<Order>,
    /// The outer radius in pixels of arc marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<RadiusClass>,
    /// The inner radius in pixels of arc marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<Radius2Class>,
    /// A field definition for the vertical facet of trellis plots.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row: Option<RowColumnEncodingFieldDef>,
    /// Shape of the mark.
    ///
    /// 1. For `point` marks the supported values include:   - plotting shapes: `"circle"`,
    /// `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`, `"triangle-down"`,
    /// `"triangle-right"`, or `"triangle-left"`.   - the line symbol `"stroke"`   - centered
    /// directional shapes `"arrow"`, `"wedge"`, or `"triangle"`   - a custom [SVG path
    /// string](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths) (For correct
    /// sizing, custom shape paths should be defined within a square bounding box with
    /// coordinates ranging from -1 to 1 along both the x and y dimensions.)
    ///
    /// 2. For `geoshape` marks it should be a field definition of the geojson data
    ///
    /// __Default value:__ If undefined, the default shape depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#point-config)'s `shape`
    /// property. (`"circle"` if unset.)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<MarkPropDefStringNullTypeForShape>,
    /// Size of the mark.
    /// - For `"point"`, `"square"` and `"circle"`, – the symbol size, or pixel area of the mark.
    /// - For `"bar"` and `"tick"` – the bar and tick's size.
    /// - For `"text"` – the text's font size.
    /// - Size is unsupported for `"line"`, `"area"`, and `"rect"`. (Use `"trail"` instead of
    /// line with varying size)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<SizeClass>,
    /// Stroke color of the marks. __Default value:__ If undefined, the default color depends on
    /// [mark config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `color`
    /// property.
    ///
    /// _Note:_ The `stroke` encoding has higher precedence than `color`, thus may override the
    /// `color` encoding if conflicting encodings are specified.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<StrokeClass>,
    /// Stroke dash of the marks.
    ///
    /// __Default value:__ `[1,0]` (No dash).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<MarkPropDefNumber>,
    /// Stroke opacity of the marks.
    ///
    /// __Default value:__ If undefined, the default opacity depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeOpacity`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<StrokeOpacityClass>,
    /// Stroke width of the marks.
    ///
    /// __Default value:__ If undefined, the default stroke width depends on [mark
    /// config](https://vega.github.io/vega-lite/docs/config.html#mark-config)'s `strokeWidth`
    /// property.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<StrokeWidthClass>,
    /// Text of the `text` mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<TextDef>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<ThetaClass>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<Theta2Class>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<TimeFieldDef>,
    /// The tooltip text to show upon mouse hover. Specifying `tooltip` encoding overrides [the
    /// `tooltip` property in the mark
    /// definition](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip in Vega-Lite.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<EncodingTooltip>,
    /// The URL of an image mark.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<UrlClass>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XClass>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<X2Class>,
    /// Error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_error: Option<XErrorClass>,
    /// Secondary error value of x coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_error2: Option<XError2Class>,
    /// Offset of x-position of the marks
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<XOffsetClass>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YClass>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<Y2Class>,
    /// Error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_error: Option<YErrorClass>,
    /// Secondary error value of y coordinates for error specified `"errorbar"` and `"errorband"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_error2: Option<YError2Class>,
    /// Offset of y-position of the marks
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<YOffsetClass>,
}

/// Vega-Lite configuration object. This property can only be defined at the top-level of a
/// specification.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ConfigClass {
    /// Arc-specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub arc: Option<RectConfig>,
    /// Area-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub area: Option<AreaConfig>,
    /// A boolean flag indicating if ARIA default attributes should be included for marks and
    /// guides (SVG output only). If false, the `"aria-hidden"` attribute will be set for all
    /// guides, removing them from the ARIA accessibility tree and Vega-Lite will not generate
    /// default descriptions for marks.
    ///
    /// __Default value:__ `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<bool>,
    /// How the visualization size should be determined. If a string, should be one of `"pad"`,
    /// `"fit"` or `"none"`. Object values can additionally specify parameters for content sizing
    /// and automatic resizing.
    ///
    /// __Default value__: `pad`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub autosize: Option<Box<Autosize>>,
    /// Axis configuration, which determines default properties for all `x` and `y`
    /// [axes](https://vega.github.io/vega-lite/docs/axis.html). For a full list of axis
    /// configuration options, please see the [corresponding section of the axis
    /// documentation](https://vega.github.io/vega-lite/docs/axis.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis: Option<AxisConfig>,
    /// Config for axes with "band" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_band: Option<AxisConfig>,
    /// Config for x-axis along the bottom edge of the chart.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_bottom: Option<AxisConfig>,
    /// Config for axes with "point" or "band" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_discrete: Option<AxisConfig>,
    /// Config for y-axis along the left edge of the chart.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_left: Option<AxisConfig>,
    /// Config for axes with "point" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_point: Option<AxisConfig>,
    /// Config for quantitative axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_quantitative: Option<AxisConfig>,
    /// Config for y-axis along the right edge of the chart.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_right: Option<AxisConfig>,
    /// Config for temporal axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_temporal: Option<AxisConfig>,
    /// Config for x-axis along the top edge of the chart.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_top: Option<AxisConfig>,
    /// X-axis specific config.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_x: Option<AxisConfig>,
    /// Config for x-axes with "band" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_x_band: Option<AxisConfig>,
    /// Config for x-axes with "point" or "band" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_x_discrete: Option<AxisConfig>,
    /// Config for x-axes with "point" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_x_point: Option<AxisConfig>,
    /// Config for x-quantitative axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_x_quantitative: Option<AxisConfig>,
    /// Config for x-temporal axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_x_temporal: Option<AxisConfig>,
    /// Y-axis specific config.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_y: Option<AxisConfig>,
    /// Config for y-axes with "band" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_y_band: Option<AxisConfig>,
    /// Config for y-axes with "point" or "band" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_y_discrete: Option<AxisConfig>,
    /// Config for y-axes with "point" scales.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_y_point: Option<AxisConfig>,
    /// Config for y-quantitative axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_y_quantitative: Option<AxisConfig>,
    /// Config for y-temporal axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub axis_y_temporal: Option<AxisConfig>,
    /// CSS color property to use as the background of the entire view.
    ///
    /// __Default value:__ `"white"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub background: Option<Box<Color>>,
    /// Bar-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bar: Option<BarConfig>,
    /// Box Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub boxplot: Option<BoxPlotConfig>,
    /// Circle-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub circle: Option<MarkConfig>,
    /// Default configuration for all concatenation and repeat view composition operators
    /// (`concat`, `hconcat`, `vconcat`, and `repeat`)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub concat: Option<CompositionConfig>,
    /// Default axis and legend title for count fields.
    ///
    /// __Default value:__ `'Count of Records`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub count_title: Option<String>,
    /// Allow the `formatType` property for text marks and guides to accept a custom formatter
    /// function [registered as a Vega
    /// expression](https://vega.github.io/vega-lite/usage/compile.html#format-type).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub custom_format_types: Option<bool>,
    /// ErrorBand Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub errorband: Option<ErrorBandConfig>,
    /// ErrorBar Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub errorbar: Option<ErrorBarConfig>,
    /// Default configuration for the `facet` view composition operator
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<CompositionConfig>,
    /// Defines how Vega-Lite generates title for fields. There are three possible styles:
    /// - `"verbal"` (Default) - displays function in a verbal style (e.g., "Sum of field",
    /// "Year-month of date", "field (binned)").
    /// - `"function"` - displays function using parentheses and capitalized texts (e.g.,
    /// "SUM(field)", "YEARMONTH(date)", "BIN(field)").
    /// - `"plain"` - displays only the field name without functions (e.g., "field", "date",
    /// "field").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub field_title: Option<FieldTitle>,
    /// Default font for all text marks, titles, and labels.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<String>,
    /// Geoshape-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub geoshape: Option<MarkConfig>,
    /// Header configuration, which determines default properties for all
    /// [headers](https://vega.github.io/vega-lite/docs/header.html).
    ///
    /// For a full list of header configuration options, please see the [corresponding section of
    /// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header: Option<HeaderConfig>,
    /// Header configuration, which determines default properties for column
    /// [headers](https://vega.github.io/vega-lite/docs/header.html).
    ///
    /// For a full list of header configuration options, please see the [corresponding section of
    /// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header_column: Option<HeaderConfig>,
    /// Header configuration, which determines default properties for non-row/column facet
    /// [headers](https://vega.github.io/vega-lite/docs/header.html).
    ///
    /// For a full list of header configuration options, please see the [corresponding section of
    /// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header_facet: Option<HeaderConfig>,
    /// Header configuration, which determines default properties for row
    /// [headers](https://vega.github.io/vega-lite/docs/header.html).
    ///
    /// For a full list of header configuration options, please see the [corresponding section of
    /// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub header_row: Option<HeaderConfig>,
    /// Image-specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub image: Option<RectConfig>,
    /// Legend configuration, which determines default properties for all
    /// [legends](https://vega.github.io/vega-lite/docs/legend.html). For a full list of legend
    /// configuration options, please see the [corresponding section of in the legend
    /// documentation](https://vega.github.io/vega-lite/docs/legend.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend: Option<LegendConfig>,
    /// Line-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line: Option<LineConfig>,
    /// A delimiter, such as a newline character, upon which to break text strings into multiple
    /// lines. This property provides a global default for text marks, which is overridden by
    /// mark or style config settings, and by the lineBreak mark encoding channel. If
    /// signal-valued, either string or regular expression (regexp) values are valid.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    /// Locale definitions for string parsing and formatting of number and date values. The
    /// locale object should contain `number` and/or `time` properties with [locale
    /// definitions](https://vega.github.io/vega/docs/api/locale/). Locale definitions provided
    /// in the config block may be overridden by the View constructor locale option.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub locale: Option<Locale>,
    /// Mark Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<MarkConfig>,
    /// If normalizedNumberFormatType is not specified, D3 number format for axis labels, text
    /// marks, and tooltips of normalized stacked fields (fields with `stack: "normalize"`). For
    /// example `"s"` for SI units. Use [D3's number format
    /// pattern](https://github.com/d3/d3-format#locale_format).
    ///
    /// If `config.normalizedNumberFormatType` is specified and `config.customFormatTypes` is
    /// `true`, this value will be passed as `format` alongside `datum.value` to the
    /// `config.numberFormatType` function. __Default value:__ `%`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub normalized_number_format: Option<String>,
    /// [Custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type) for
    /// `config.normalizedNumberFormat`.
    ///
    /// __Default value:__ `undefined` -- This is equilvalent to call D3-format, which is exposed
    /// as [`format` in Vega-Expression](https://vega.github.io/vega/docs/expressions/#format).
    /// __Note:__ You must also set `customFormatTypes` to `true` to use this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub normalized_number_format_type: Option<String>,
    /// If numberFormatType is not specified, D3 number format for guide labels, text marks, and
    /// tooltips of non-normalized fields (fields *without* `stack: "normalize"`). For example
    /// `"s"` for SI units. Use [D3's number format
    /// pattern](https://github.com/d3/d3-format#locale_format).
    ///
    /// If `config.numberFormatType` is specified and `config.customFormatTypes` is `true`, this
    /// value will be passed as `format` alongside `datum.value` to the `config.numberFormatType`
    /// function.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub number_format: Option<String>,
    /// [Custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type) for
    /// `config.numberFormat`.
    ///
    /// __Default value:__ `undefined` -- This is equilvalent to call D3-format, which is exposed
    /// as [`format` in Vega-Expression](https://vega.github.io/vega/docs/expressions/#format).
    /// __Note:__ You must also set `customFormatTypes` to `true` to use this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub number_format_type: Option<String>,
    /// The default visualization padding, in pixels, from the edge of the visualization canvas
    /// to the data rectangle. If a number, specifies padding for all sides. If an object, the
    /// value should have the format `{"left": 5, "top": 5, "right": 5, "bottom": 5}` to specify
    /// padding for each side of the visualization.
    ///
    /// __Default value__: `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding: Option<Box<Padding>>,
    /// Dynamic variables or selections that parameterize a visualization.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<Vec<TopLevelParameter>>,
    /// Point-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<MarkConfig>,
    /// Projection configuration, which determines default properties for all
    /// [projections](https://vega.github.io/vega-lite/docs/projection.html). For a full list of
    /// projection configuration options, please see the [corresponding section of the projection
    /// documentation](https://vega.github.io/vega-lite/docs/projection.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection: Option<Box<Projection>>,
    /// An object hash that defines default range arrays or schemes for using with scales. For a
    /// full list of scale range configuration options, please see the [corresponding section of
    /// the scale documentation](https://vega.github.io/vega-lite/docs/scale.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub range: Option<HashMap<String, RangeValue>>,
    /// Rect-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rect: Option<RectConfig>,
    /// Rule-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rule: Option<MarkConfig>,
    /// Scale configuration determines default properties for all
    /// [scales](https://vega.github.io/vega-lite/docs/scale.html). For a full list of scale
    /// configuration options, please see the [corresponding section of the scale
    /// documentation](https://vega.github.io/vega-lite/docs/scale.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub scale: Option<ScaleConfig>,
    /// An object hash for defining default properties for each type of selections.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub selection: Option<SelectionClass>,
    /// Square-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub square: Option<MarkConfig>,
    /// An object hash that defines key-value mappings to determine default properties for marks
    /// with a given [style](https://vega.github.io/vega-lite/docs/mark.html#mark-def). The keys
    /// represent styles names; the values have to be valid [mark configuration
    /// objects](https://vega.github.io/vega-lite/docs/mark.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<HashMap<String, StyleValue>>,
    /// Text-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<MarkConfig>,
    /// Tick-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick: Option<TickConfig>,
    /// Default time format for raw time values (without time units) in text marks, legend labels
    /// and header labels.
    ///
    /// __Default value:__ `"%b %d, %Y"` __Note:__ Axes automatically determine the format for
    /// each label automatically so this config does not affect axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_format: Option<String>,
    /// [Custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type) for
    /// `config.timeFormat`.
    ///
    /// __Default value:__ `undefined` -- This is equilvalent to call D3-time-format, which is
    /// exposed as [`timeFormat` in
    /// Vega-Expression](https://vega.github.io/vega/docs/expressions/#timeFormat). __Note:__ You
    /// must also set `customFormatTypes` to `true` and there must *not* be a `timeUnit` defined
    /// to use this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_format_type: Option<String>,
    /// Title configuration, which determines default properties for all
    /// [titles](https://vega.github.io/vega-lite/docs/title.html). For a full list of title
    /// configuration options, please see the [corresponding section of the title
    /// documentation](https://vega.github.io/vega-lite/docs/title.html#config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title: Option<BaseTitleNoValueRefs>,
    /// Define [custom format
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#format) for tooltips. If
    /// unspecified, default format config will be applied.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip_format: Option<FormatConfig>,
    /// Trail-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub trail: Option<LineConfig>,
    /// Default properties for [single view
    /// plots](https://vega.github.io/vega-lite/docs/spec.html#single).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub view: Option<ViewConfig>,
}

/// Arc-specific Config
///
/// Image-specific Config
///
/// Rect-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RectConfig {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    /// Offset between bars for binned field. The ideal value for this is either 0 (preferred by
    /// statisticians) or 1 (Vega-Lite default, D3 example style).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin_spacing: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    /// The default size of the bars on continuous scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_band_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    /// The default size of the bars with discrete dimensions. If unspecified, the default size
    /// is  `step-2`, which provides 2 pixel offset between bars.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_band_size: Option<DiscreteBandSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The minimum band size for bar and rectangle marks. __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
}

/// Area-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AreaConfig {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    /// A flag for overlaying line on top of area marks, or an object defining the properties of
    /// the overlayed lines.
    ///
    /// - If this value is an empty object (`{}`) or `true`, lines with default properties will
    /// be used.
    ///
    /// - If this value is `false`, no lines would be automatically added to area marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line: Option<Line>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// A flag for overlaying points on top of line or area marks, or an object defining the
    /// properties of the overlayed points.
    ///
    /// - If this property is `"transparent"`, transparent points will be used (for enhancing
    /// tooltips and selections).
    ///
    /// - If this property is an empty object (`{}`) or `true`, filled points with default
    /// properties will be used.
    ///
    /// - If this property is `false`, no points would be automatically added to line or area
    /// marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<PointUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
}

/// Axis configuration, which determines default properties for all `x` and `y`
/// [axes](https://vega.github.io/vega-lite/docs/axis.html). For a full list of axis
/// configuration options, please see the [corresponding section of the axis
/// documentation](https://vega.github.io/vega-lite/docs/axis.html#config).
///
/// Config for axes with "band" scales.
///
/// Config for x-axis along the bottom edge of the chart.
///
/// Config for axes with "point" or "band" scales.
///
/// Config for y-axis along the left edge of the chart.
///
/// Config for axes with "point" scales.
///
/// Config for quantitative axes.
///
/// Config for y-axis along the right edge of the chart.
///
/// Config for temporal axes.
///
/// Config for x-axis along the top edge of the chart.
///
/// X-axis specific config.
///
/// Config for x-axes with "band" scales.
///
/// Config for x-axes with "point" or "band" scales.
///
/// Config for x-axes with "point" scales.
///
/// Config for x-quantitative axes.
///
/// Config for x-temporal axes.
///
/// Y-axis specific config.
///
/// Config for y-axes with "band" scales.
///
/// Config for y-axes with "point" or "band" scales.
///
/// Config for y-axes with "point" scales.
///
/// Config for y-quantitative axes.
///
/// Config for y-temporal axes.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AxisConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    /// Disable axis by default.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub disable: Option<bool>,
    /// A boolean flag indicating if the domain (the axis baseline) should be included as part of
    /// the axis.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_width: Option<CornerRadiusUnion>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// A boolean flag indicating if grid lines should be included as part of the axis
    ///
    /// __Default value:__ `true` for [continuous
    /// scales](https://vega.github.io/vega-lite/docs/scale.html#continuous) that are not binned;
    /// otherwise, `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_color: Option<GridColorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_dash: Option<AxisBandGridDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_dash_offset: Option<GridDashOffsetUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_opacity: Option<GridOpacityUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_width: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<ConditionalAxisPropertyAlignNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_angle: Option<LabelAngle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<PurpleTextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_bound: Option<Label>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<GridColorUnion>,
    /// [Vega expression](https://vega.github.io/vega/docs/expressions/) for customizing labels.
    ///
    /// __Note:__ The label text and value can be assessed via the `label` and `value` properties
    /// of the axis's backing `datum` object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_expr: Option<String>,
    /// Indicates if the first and last axis labels should be aligned flush with the scale range.
    /// Flush alignment for a horizontal axis will left-align the first label and right-align the
    /// last label. For vertical axes, bottom and top text baselines are applied instead. If this
    /// property is a number, it also indicates the number of pixels by which to offset the first
    /// and last labels; for example, a value of 2 will flush-align the first and last labels and
    /// also push them 2 pixels outward from the center of the axis. The additional adjustment
    /// can sometimes help the labels better visually group with corresponding axis ticks.
    ///
    /// __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_flush: Option<LabelFlush>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_flush_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<ConditionalAxisPropertyStringNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<ConditionalAxisPropertyFontStyleNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeight>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_offset: Option<GridDashOffsetUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_opacity: Option<GridDashOffsetUnion>,
    /// The strategy to use for resolving overlap of axis labels. If `false` (the default), no
    /// overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
    /// every other label is used (this works well for standard linear axes). If set to
    /// `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
    /// with the last visible label (this often works better for log-scaled axes).
    ///
    /// __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
    /// scales; otherwise `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_overlap: Option<LabelOverlapUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<GridDashOffsetUnion>,
    /// A boolean flag indicating if labels should be included as part of the axis.
    ///
    /// __Default value:__ `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_separation: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_extent: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_extent: Option<CornerRadiusUnion>,
    /// The offset, in pixels, by which to displace the axis from the edge of the enclosing group
    /// or data rectangle.
    ///
    /// __Default value:__ derived from the [axis
    /// config](https://vega.github.io/vega-lite/docs/config.html#facet-scale-config)'s `offset`
    /// (`0` by default)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    /// The orientation of the axis. One of `"top"`, `"bottom"`, `"left"` or `"right"`. The
    /// orientation can be used to further specialize the axis type (e.g., a y-axis oriented
    /// towards the right edge of the chart).
    ///
    /// __Default value:__ `"bottom"` for x-axes and `"left"` for y-axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<TitleOrientUnion>,
    /// The anchor position of the axis in pixels. For x-axes with top or bottom orientation,
    /// this sets the axis group x coordinate. For y-axes with left or right orientation, this
    /// sets the axis group y coordinate.
    ///
    /// __Default value__: `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position: Option<CornerRadiusUnion>,
    /// A string or array of strings indicating the name of custom styles to apply to the axis. A
    /// style is a named collection of axis property defined within the [style
    /// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
    /// an array, later styles will override earlier styles.
    ///
    /// __Default value:__ (none) __Note:__ Any specified style will augment the default style.
    /// For example, an x-axis mark with `"style": "foo"` will use `config.axisX` and
    /// `config.style.foo` (the specified style `"foo"` has higher precedence).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_band: Option<TickBandUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_color: Option<GridColorUnion>,
    /// A desired number of ticks, for axes visualizing quantitative scales. The resulting number
    /// may be different so that values are "nice" (multiples of 2, 5, 10) and lie within the
    /// underlying scale's range.
    ///
    /// For scales of type `"time"` or `"utc"`, the tick count can instead be a time interval
    /// specifier. Legal string values are `"millisecond"`, `"second"`, `"minute"`, `"hour"`,
    /// `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, an object-valued interval
    /// specifier of the form `{"interval": "month", "step": 3}` includes a desired number of
    /// interval steps. Here, ticks are generated for each quarter (Jan, Apr, Jul, Oct)
    /// boundary.
    ///
    /// __Default value__: Determine using a formula `ceil(width/40)` for x and `ceil(height/40)`
    /// for y.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_count: Option<TickCount>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_dash: Option<AxisBandTickDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_dash_offset: Option<GridDashOffsetUnion>,
    /// Boolean flag indicating if an extra axis tick should be added for the initial position of
    /// the axis. This flag is useful for styling axes for `band` scales such that ticks are
    /// placed on band boundaries rather in the middle of a band. Use in conjunction with
    /// `"bandPosition": 1` and an axis `"padding"` value of `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_extra: Option<bool>,
    /// The minimum desired step between axis ticks, in terms of scale domain values. For
    /// example, a value of `1` indicates that ticks should not be less than 1 unit apart. If
    /// `tickMinStep` is specified, the `tickCount` value will be adjusted, if necessary, to
    /// enforce the minimum step value.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_min_step: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_opacity: Option<GridDashOffsetUnion>,
    /// Boolean flag indicating if pixel position values should be rounded to the nearest
    /// integer.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_round: Option<bool>,
    /// Boolean value that determines whether the axis should include ticks.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ticks: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_size: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_width: Option<GridWidthUnion>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_angle: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_x: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_y: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub translate: Option<CornerRadiusUnion>,
    /// Explicitly set the visible axis tick values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub values: Option<Values>,
    /// A non-negative integer indicating the z-index of the axis. If zindex is 0, axes should be
    /// drawn behind all chart elements. To put them in front, set `zindex` to `1` or more.
    ///
    /// __Default value:__ `0` (behind the marks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AxisBandGridDash {
    AmbitiousExprRef(AmbitiousExprRef),
    DoubleArray(Vec<f64>),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct AmbitiousExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<TentacledConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum AxisBandTickDash {
    CunningExprRef(CunningExprRef),
    DoubleArray(Vec<f64>),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct CunningExprRef {
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub condition: Option<TentacledConditionalPredicateValueDefNumberNullExprRef>,
    /// A constant value in visual domain (e.g., `"red"` / `"#0099ff"` / [gradient
    /// definition](https://vega.github.io/vega-lite/docs/types.html#gradient) for color, values
    /// between `0` to `1` for opacity).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
}

/// Bar-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BarConfig {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    /// Offset between bars for binned field. The ideal value for this is either 0 (preferred by
    /// statisticians) or 1 (Vega-Lite default, D3 example style).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin_spacing: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    /// The default size of the bars on continuous scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_band_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    /// - For vertical bars, top-left and top-right corner radius.
    ///
    /// - For horizontal bars, top-right and bottom-right corner radius.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_end: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    /// The default size of the bars with discrete dimensions. If unspecified, the default size
    /// is  `step-2`, which provides 2 pixel offset between bars.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_band_size: Option<DiscreteBandSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The minimum band size for bar and rectangle marks. __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
}

/// Box Config
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BoxPlotConfig {
    #[serde(rename = "box")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub box_plot_config_box: Option<AnyMarkConfig>,
    /// The extent of the whiskers. Available options include:
    /// - `"min-max"`: min and max are the lower and upper whiskers respectively.
    /// - A number representing multiple of the interquartile range. This number will be
    /// multiplied by the IQR to determine whisker boundary, which spans from the smallest data
    /// to the largest data within the range _[Q1 - k * IQR, Q3 + k * IQR]_ where _Q1_ and _Q3_
    /// are the first and third quartiles while _IQR_ is the interquartile range (_Q3-Q1_).
    ///
    /// __Default value:__ `1.5`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<BoxplotExtent>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub median: Option<AnyMarkConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outliers: Option<AnyMarkConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rule: Option<AnyMarkConfig>,
    /// Size of the box and median tick of a box plot
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ticks: Option<AnyMarkConfig>,
}

/// The extent of the whiskers. Available options include:
/// - `"min-max"`: min and max are the lower and upper whiskers respectively.
/// - A number representing multiple of the interquartile range. This number will be
/// multiplied by the IQR to determine whisker boundary, which spans from the smallest data
/// to the largest data within the range _[Q1 - k * IQR, Q3 + k * IQR]_ where _Q1_ and _Q3_
/// are the first and third quartiles while _IQR_ is the interquartile range (_Q3-Q1_).
///
/// __Default value:__ `1.5`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum BoxplotExtent {
    Double(f64),
    Enum(ExtentEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ExtentEnum {
    #[serde(rename = "min-max")]
    MinMax,
}

/// Circle-Specific Config
///
/// Geoshape-Specific Config
///
/// Mark Config
///
/// Point-Specific Config
///
/// Rule-Specific Config
///
/// Square-Specific Config
///
/// Default style for chart subtitles
///
/// Default style for chart titles
///
/// Default style for axis, legend, and header labels.
///
/// Default style for axis, legend, and header titles.
///
/// Text-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct MarkConfig {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
}

/// Default configuration for all concatenation and repeat view composition operators
/// (`concat`, `hconcat`, `vconcat`, and `repeat`)
///
/// Default configuration for the `facet` view composition operator
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct CompositionConfig {
    /// The number of columns to include in the view composition layout.
    ///
    /// __Default value__: `undefined` -- An infinite number of columns (a single row) will be
    /// assumed. This is equivalent to `hconcat` (for `concat`) and to using the `column` channel
    /// (for `facet` and `repeat`).
    ///
    /// __Note__:
    ///
    /// 1) This property is only for:
    /// - the general (wrappable) `concat` operator (not `hconcat`/`vconcat`)
    /// - the `facet` and `repeat` operator with one field/repetition definition (without
    /// row/column nesting)
    ///
    /// 2) Setting the `columns` to `1` is equivalent to `vconcat` (for `concat`) and to using
    /// the `row` channel (for `facet` and `repeat`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<f64>,
    /// The default spacing in pixels between composed sub-views.
    ///
    /// __Default value__: `20`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<f64>,
}

/// ErrorBand Config
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ErrorBandConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band: Option<AnyMarkConfig>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub borders: Option<AnyMarkConfig>,
    /// The extent of the band. Available options include:
    /// - `"ci"`: Extend the band to the 95% bootstrapped confidence interval of the mean.
    /// - `"stderr"`: The size of band are set to the value of standard error, extending from the
    /// mean.
    /// - `"stdev"`: The size of band are set to the value of standard deviation, extending from
    /// the mean.
    /// - `"iqr"`: Extend the band to the q1 and q3.
    ///
    /// __Default value:__ `"stderr"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<ErrorbandExtent>,
    /// The line interpolation method for the error band. One of the following:
    /// - `"linear"`: piecewise linear segments, as in a polyline.
    /// - `"linear-closed"`: close the linear segments to form a polygon.
    /// - `"step"`: 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.
    /// - `"step-before"`: a piecewise constant function (a step function) consisting of
    /// alternating horizontal and vertical lines. The y-value changes before the x-value.
    /// - `"step-after"`: a piecewise constant function (a step function) consisting of
    /// alternating horizontal and vertical lines. The y-value changes after the x-value.
    /// - `"basis"`: a B-spline, with control point duplication on the ends.
    /// - `"basis-open"`: an open B-spline; may not intersect the start or end.
    /// - `"basis-closed"`: a closed B-spline, as in a loop.
    /// - `"cardinal"`: a Cardinal spline, with control point duplication on the ends.
    /// - `"cardinal-open"`: an open Cardinal spline; may not intersect the start or end, but
    /// will intersect other control points.
    /// - `"cardinal-closed"`: a closed Cardinal spline, as in a loop.
    /// - `"bundle"`: equivalent to basis, except the tension parameter is used to straighten the
    /// spline.
    /// - `"monotone"`: cubic interpolation that preserves monotonicity in y.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<Interpolate>,
    /// The tension parameter for the interpolation type of the error band.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<f64>,
}

/// The extent of the band. Available options include:
/// - `"ci"`: Extend the band to the 95% bootstrapped confidence interval of the mean.
/// - `"stderr"`: The size of band are set to the value of standard error, extending from the
/// mean.
/// - `"stdev"`: The size of band are set to the value of standard deviation, extending from
/// the mean.
/// - `"iqr"`: Extend the band to the q1 and q3.
///
/// __Default value:__ `"stderr"`.
///
/// The extent of the rule. Available options include:
/// - `"ci"`: Extend the rule to the 95% bootstrapped confidence interval of the mean.
/// - `"stderr"`: The size of rule are set to the value of standard error, extending from the
/// mean.
/// - `"stdev"`: The size of rule are set to the value of standard deviation, extending from
/// the mean.
/// - `"iqr"`: Extend the rule to the q1 and q3.
///
/// __Default value:__ `"stderr"`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ErrorbandExtent {
    Ci,
    Iqr,
    Stderr,
    Stdev,
}

/// ErrorBar Config
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ErrorBarConfig {
    /// The extent of the rule. Available options include:
    /// - `"ci"`: Extend the rule to the 95% bootstrapped confidence interval of the mean.
    /// - `"stderr"`: The size of rule are set to the value of standard error, extending from the
    /// mean.
    /// - `"stdev"`: The size of rule are set to the value of standard deviation, extending from
    /// the mean.
    /// - `"iqr"`: Extend the rule to the q1 and q3.
    ///
    /// __Default value:__ `"stderr"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<ErrorbandExtent>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rule: Option<AnyMarkConfig>,
    /// Size of the ticks of an error bar
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<f64>,
    /// Thickness of the ticks and the bar of an error bar
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub thickness: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ticks: Option<AnyMarkConfig>,
}

/// Defines how Vega-Lite generates title for fields. There are three possible styles:
/// - `"verbal"` (Default) - displays function in a verbal style (e.g., "Sum of field",
/// "Year-month of date", "field (binned)").
/// - `"function"` - displays function using parentheses and capitalized texts (e.g.,
/// "SUM(field)", "YEARMONTH(date)", "BIN(field)").
/// - `"plain"` - displays only the field name without functions (e.g., "field", "date",
/// "field").
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FieldTitle {
    Functional,
    Plain,
    Verbal,
}

/// Header configuration, which determines default properties for all
/// [headers](https://vega.github.io/vega-lite/docs/header.html).
///
/// For a full list of header configuration options, please see the [corresponding section of
/// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
///
/// Header configuration, which determines default properties for column
/// [headers](https://vega.github.io/vega-lite/docs/header.html).
///
/// For a full list of header configuration options, please see the [corresponding section of
/// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
///
/// Header configuration, which determines default properties for non-row/column facet
/// [headers](https://vega.github.io/vega-lite/docs/header.html).
///
/// For a full list of header configuration options, please see the [corresponding section of
/// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
///
/// Header configuration, which determines default properties for row
/// [headers](https://vega.github.io/vega-lite/docs/header.html).
///
/// For a full list of header configuration options, please see the [corresponding section of
/// in the header documentation](https://vega.github.io/vega-lite/docs/header.html#config).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct HeaderConfig {
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// Horizontal text alignment of header labels. One of `"left"`, `"center"`, or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<TitleAlignUnion>,
    /// The anchor position for placing the labels. One of `"start"`, `"middle"`, or `"end"`. For
    /// example, with a label orientation of top these anchor positions map to a left-, center-,
    /// or right-aligned label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_anchor: Option<TitleAnchorEnum>,
    /// The rotation angle of the header labels.
    ///
    /// __Default value:__ `0` for column header, `-90` for row header.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_angle: Option<f64>,
    /// The vertical text baseline for the header labels. One of `"alphabetic"` (default),
    /// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
    /// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
    /// relative to the `titleLineHeight` rather than `titleFontSize` alone.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<TextBaseline>,
    /// The color of the header label, can be in hex color code or regular color name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<Box<Color>>,
    /// [Vega expression](https://vega.github.io/vega/docs/expressions/) for customizing labels.
    ///
    /// __Note:__ The label text and value can be assessed via the `label` and `value` properties
    /// of the header's backing `datum` object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_expr: Option<String>,
    /// The font of the header label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<Box<Color>>,
    /// The font size of the header label, in pixels.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<CornerRadiusUnion>,
    /// The font style of the header label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<Box<Color>>,
    /// The font weight of the header label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeightUnion>,
    /// The maximum length of the header label in pixels. The text value will be automatically
    /// truncated if the rendered size exceeds the limit.
    ///
    /// __Default value:__ `0`, indicating no limit
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    /// Line height in pixels for multi-line header labels or title text with `"line-top"` or
    /// `"line-bottom"` baseline.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_line_height: Option<CornerRadiusUnion>,
    /// The orientation of the header label. One of `"top"`, `"bottom"`, `"left"` or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_orient: Option<Orient>,
    /// The padding, in pixel, between facet header's label and the plot.
    ///
    /// __Default value:__ `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<CornerRadiusUnion>,
    /// A boolean flag indicating if labels should be included as part of the header.
    ///
    /// __Default value:__ `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<bool>,
    /// Shortcut for setting both labelOrient and titleOrient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orient>,
    /// Set to null to disable title for the axis, legend, or header.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<serde_json::Value>,
    /// Horizontal text alignment (to the anchor) of header titles.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    /// The anchor position for placing the title. One of `"start"`, `"middle"`, or `"end"`. For
    /// example, with an orientation of top these anchor positions map to a left-, center-, or
    /// right-aligned title.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorEnum>,
    /// The rotation angle of the header title.
    ///
    /// __Default value:__ `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_angle: Option<f64>,
    /// The vertical text baseline for the header title. One of `"alphabetic"` (default),
    /// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
    /// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
    /// relative to the `titleLineHeight` rather than `titleFontSize` alone.
    ///
    /// __Default value:__ `"middle"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    /// Color of the header title, can be in hex color code or regular color name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    /// Font of the header title. (e.g., `"Helvetica Neue"`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    /// Font size of the header title.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<CornerRadiusUnion>,
    /// The font style of the header title.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    /// Font weight of the header title. This can be either a string (e.g `"bold"`, `"normal"`)
    /// or a number (`100`, `200`, `300`, ..., `900` where `"normal"` = `400` and `"bold"` =
    /// `700`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    /// The maximum length of the header title in pixels. The text value will be automatically
    /// truncated if the rendered size exceeds the limit.
    ///
    /// __Default value:__ `0`, indicating no limit
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<CornerRadiusUnion>,
    /// Line height in pixels for multi-line header title text or title text with `"line-top"` or
    /// `"line-bottom"` baseline.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    /// The orientation of the header title. One of `"top"`, `"bottom"`, `"left"` or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_orient: Option<Orient>,
    /// The padding, in pixel, between facet header's title and the label.
    ///
    /// __Default value:__ `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
}

/// Legend configuration, which determines default properties for all
/// [legends](https://vega.github.io/vega-lite/docs/legend.html). For a full list of legend
/// configuration options, please see the [corresponding section of in the legend
/// documentation](https://vega.github.io/vega-lite/docs/legend.html#config).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LegendConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub column_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    /// The direction of the legend, one of `"vertical"` or `"horizontal"`.
    ///
    /// __Default value:__
    /// - For top-/bottom-`orient`ed legends, `"horizontal"`
    /// - For left-/right-`orient`ed legends, `"vertical"`
    /// - For top/bottom-left/right-`orient`ed legends, `"horizontal"` for gradient legends and
    /// `"vertical"` for symbol legends.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub direction: Option<Orientation>,
    /// Disable legend by default
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub disable: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_direction: Option<Direction>,
    /// Max legend length for a horizontal gradient when `config.legend.gradientLength` is
    /// undefined.
    ///
    /// __Default value:__ `200`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_horizontal_max_length: Option<f64>,
    /// Min legend length for a horizontal gradient when `config.legend.gradientLength` is
    /// undefined.
    ///
    /// __Default value:__ `100`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_horizontal_min_length: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_label_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_label_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_length: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_thickness: Option<FontSize>,
    /// Max legend length for a vertical gradient when `config.legend.gradientLength` is
    /// undefined.
    ///
    /// __Default value:__ `200`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_vertical_max_length: Option<f64>,
    /// Min legend length for a vertical gradient when `config.legend.gradientLength` is
    /// undefined.
    ///
    /// __Default value:__ `100`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient_vertical_min_length: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_align: Option<GridAlign>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_offset: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_opacity: Option<CornerRadiusUnion>,
    /// The strategy to use for resolving overlap of labels in gradient legends. If `false`, no
    /// overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
    /// every other label is used. If set to `"greedy"`, a linear scan of the labels is
    /// performed, removing any label that overlaps with the last visible label (this often works
    /// better for log-scaled axes).
    ///
    /// __Default value:__ `"greedy"` for `log scales otherwise `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_overlap: Option<LabelOverlapUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_separation: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layout: Option<BackgroundExprRef>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend_x: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub legend_y: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    /// The orientation of the legend, which determines how the legend is positioned within the
    /// scene. One of `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
    /// `"bottom-left"`, `"bottom-right"`, `"none"`.
    ///
    /// __Default value:__ `"right"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<LegendOrient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub row_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_base_fill_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_base_stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_direction: Option<Direction>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_fill_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_stroke_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub symbol_type: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_count: Option<TickCount>,
    /// Set to null to disable title for the axis, legend, or header.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_orient: Option<TitleOrientUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
    /// The opacity of unselected legend entries.
    ///
    /// __Default value:__ 0.35.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub unselected_opacity: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<FontSize>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Direction {
    BackgroundExprRef(BackgroundExprRef),
    Enum(Orientation),
}

/// Line-Specific Config
///
/// Trail-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct LineConfig {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// A flag for overlaying points on top of line or area marks, or an object defining the
    /// properties of the overlayed points.
    ///
    /// - If this property is `"transparent"`, transparent points will be used (for enhancing
    /// tooltips and selections).
    ///
    /// - If this property is an empty object (`{}`) or `true`, filled points with default
    /// properties will be used.
    ///
    /// - If this property is `false`, no points would be automatically added to line or area
    /// marks.
    ///
    /// __Default value:__ `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<PointUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
}

/// Locale definitions for string parsing and formatting of number and date values. The
/// locale object should contain `number` and/or `time` properties with [locale
/// definitions](https://vega.github.io/vega/docs/api/locale/). Locale definitions provided
/// in the config block may be overridden by the View constructor locale option.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct Locale {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub number: Option<NumberLocale>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<TimeLocale>,
}

/// Locale definition for formatting numbers.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct NumberLocale {
    /// The currency prefix and suffix (e.g., ["$", ""]).
    pub currency: Vec<String>,
    /// The decimal point (e.g., ".").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub decimal: Option<String>,
    /// The array of group sizes (e.g., [3]), cycled as needed.
    pub grouping: Vec<f64>,
    /// The minus sign (defaults to hyphen-minus, "-").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub minus: Option<String>,
    /// The not-a-number value (defaults to "NaN").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub nan: Option<String>,
    /// An array of ten strings to replace the numerals 0-9.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub numerals: Option<Vec<String>>,
    /// The percent sign (defaults to "%").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub percent: Option<String>,
    /// The group separator (e.g., ",").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub thousands: Option<String>,
}

/// Locale definition for formatting dates and times.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TimeLocale {
    /// The date (%x) format specifier (e.g., "%m/%d/%Y").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date: Option<String>,
    /// The date and time (%c) format specifier (e.g., "%a %b %e %X %Y").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub date_time: Option<String>,
    /// The full names of the weekdays, starting with Sunday.
    pub days: Vec<String>,
    /// The full names of the months (starting with January).
    pub months: Vec<String>,
    /// The A.M. and P.M. equivalents (e.g., ["AM", "PM"]).
    pub periods: Vec<String>,
    /// The abbreviated names of the weekdays, starting with Sunday.
    pub short_days: Vec<String>,
    /// The abbreviated names of the months (starting with January).
    pub short_months: Vec<String>,
    /// The time (%X) format specifier (e.g., "%H:%M:%S").
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<String>,
}

/// The default visualization padding, in pixels, from the edge of the visualization canvas
/// to the data rectangle. If a number, specifies padding for all sides. If an object, the
/// value should have the format `{"left": 5, "top": 5, "right": 5, "bottom": 5}` to specify
/// padding for each side of the visualization.
///
/// __Default value__: `5`
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum Padding {
    Double(f64),
    MagentaExprRef(MagentaExprRef),
}

/// An expression for an array of raw values that, if non-null, directly overrides the
/// _domain_ property. This is useful for supporting interactions such as panning or zooming
/// a scale. The scale may be initially determined using a data-driven domain, then modified
/// in response to user input by setting the rawDomain value.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct MagentaExprRef {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bottom: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub left: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub right: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub top: Option<f64>,
    /// Vega expression (which can refer to Vega-Lite parameters).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TopLevelParameter {
    /// Binds the parameter to an external input element such as a slider, selection list or
    /// radio button group.
    ///
    /// When set, a selection is populated by input elements (also known as dynamic query
    /// widgets) or by interacting with the corresponding legend. Direct manipulation interaction
    /// is disabled by default; to re-enable it, set the selection's
    /// [`on`](https://vega.github.io/vega-lite/docs/selection.html#common-selection-properties)
    /// property.
    ///
    /// Legend bindings are restricted to selections that only specify a single field or
    /// encoding.
    ///
    /// Query widget binding takes the form of Vega's [input element binding
    /// definition](https://vega.github.io/vega/docs/signals/#bind) or can be a mapping between
    /// projected field/encodings and binding definitions.
    ///
    /// __See also:__ [`bind`](https://vega.github.io/vega-lite/docs/bind.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bind: Option<TopLevelParameterBind>,
    /// An expression for the value of the parameter. This expression may include other
    /// parameters, in which case the parameter will automatically update in response to upstream
    /// parameter changes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub expr: Option<String>,
    /// A unique name for the variable parameter. Parameter names should be valid JavaScript
    /// identifiers: they should contain only alphanumeric characters (or "$", or "_") and may
    /// not start with a digit. Reserved keywords that may not be used as parameter names are
    /// "datum", "event", "item", and "parent".
    ///
    /// Required. A unique name for the selection parameter. Selection names should be valid
    /// JavaScript identifiers: they should contain only alphanumeric characters (or "$", or "_")
    /// and may not start with a digit. Reserved keywords that may not be used as parameter names
    /// are "datum", "event", "item", and "parent".
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// A boolean flag (default `true`) indicating if the update expression should be
    /// automatically re-evaluated when any upstream signal dependencies update. If `false`, the
    /// update expression will not register any dependencies on other signals, even for
    /// initialization.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub react: Option<bool>,
    /// The [initial value](http://vega.github.io/vega-lite/docs/value.html) of the parameter.
    ///
    /// __Default value:__ `undefined`
    ///
    /// Initialize the selection with a mapping between [projected channels or field
    /// names](https://vega.github.io/vega-lite/docs/selection.html#project) and initial values.
    ///
    /// __See also:__ [`init`](https://vega.github.io/vega-lite/docs/value.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<serde_json::Value>,
    /// Determines the default event processing and data query for the selection. Vega-Lite
    /// currently supports two selection types:
    ///
    /// - `"point"` -- to select multiple discrete data values; the first value is selected on
    /// `click` and additional values toggled on shift-click.
    /// - `"interval"` -- to select a continuous range of data values on `drag`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub select: Option<TopLevelParameterSelect>,
    /// By default, top-level selections are applied to every view in the visualization. If this
    /// property is specified, selections will only be applied to views with the given names.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub views: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TopLevelParameterBind {
    Enum(LegendBinding),
    UnionMap(HashMap<String, BindingValue>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum BindingValue {
    AnythingArray(Vec<Option<serde_json::Value>>),
    BindingBinding(BindingBinding),
    Double(f64),
    String(String),
}

/// Binds the parameter to an external input element such as a slider, selection list or
/// radio button group.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BindingBinding {
    /// If defined, delays event handling until the specified milliseconds have elapsed since the
    /// last event was fired.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub debounce: Option<f64>,
    /// An optional CSS selector string indicating the parent element to which the input element
    /// should be added. By default, all input elements are added within the parent container of
    /// the Vega view.
    ///
    /// An input element that exposes a _value_ property and supports the
    /// [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget) interface, or
    /// a CSS selector string to such an element. When the element updates and dispatches an
    /// event, the _value_ property will be used as the new, bound signal value. When the signal
    /// updates independent of the element, the _value_ property will be set to the signal value
    /// and a new event will be dispatched on the element.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub element: Option<ElementUnion>,
    /// The type of input element to use. The valid values are `"checkbox"`, `"radio"`,
    /// `"range"`, `"select"`, and any other legal [HTML form input
    /// type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub input: Option<String>,
    /// By default, the signal name is used to label input elements. This `name` property can be
    /// used instead to specify a custom label for the bound signal.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An array of label strings to represent the `options` values. If unspecified, the
    /// `options` value will be coerced to a string and used as the label.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<Vec<String>>,
    /// An array of options to select from.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub options: Option<Vec<Option<serde_json::Value>>>,
    /// Sets the maximum slider value. Defaults to the larger of the signal value and `100`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max: Option<f64>,
    /// Sets the minimum slider value. Defaults to the smaller of the signal value and `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min: Option<f64>,
    /// Sets the minimum slider increment. If undefined, the step size will be automatically
    /// determined based on the `min` and `max` values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// A hint for form autofill. See the [HTML autocomplete
    /// attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete) for
    /// additional information.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub autocomplete: Option<String>,
    /// Text that appears in the form control when it has no value set.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub placeholder: Option<String>,
    /// The event (default `"input"`) to listen for to track changes on the external element.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub event: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub between: Option<Vec<Stream>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub consume: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filter: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub markname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub marktype: Option<MarkType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub source: Option<Source>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub throttle: Option<f64>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub binding_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stream: Option<Stream>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub merge: Option<Vec<Stream>>,
}

/// Determines the default event processing and data query for the selection. Vega-Lite
/// currently supports two selection types:
///
/// - `"point"` -- to select multiple discrete data values; the first value is selected on
/// `click` and additional values toggled on shift-click.
/// - `"interval"` -- to select a continuous range of data values on `drag`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum TopLevelParameterSelect {
    Enum(SelectionType),
    SelectionConfig(SelectionConfig),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum RangeValue {
    AnythingArray(Vec<Option<serde_json::Value>>),
    Enum(RangeEnum),
    RangeClass(RangeClass),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct RangeClass {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub count: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub extent: Option<Vec<f64>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub scheme: Option<RangeText>,
}

/// A string or array of strings indicating the name of custom styles to apply to the mark. A
/// style is a named collection of mark property defaults defined within the [style
/// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
/// an array, later styles will override earlier styles. Any [mark
/// properties](https://vega.github.io/vega-lite/docs/encoding.html#mark-prop) explicitly
/// defined within the `encoding` will override a style default.
///
/// __Default value:__ The mark's name. For example, a bar mark will have style `"bar"` by
/// default. __Note:__ Any specified style will augment the default style. For example, a bar
/// mark with `"style": "foo"` will receive from `config.style.bar` and `config.style.foo`
/// (the specified style `"foo"` has higher precedence).
///
/// A string or array of strings indicating the name of custom styles to apply to the axis. A
/// style is a named collection of axis property defined within the [style
/// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
/// an array, later styles will override earlier styles.
///
/// __Default value:__ (none) __Note:__ Any specified style will augment the default style.
/// For example, an x-axis mark with `"style": "foo"` will use `config.axisX` and
/// `config.style.foo` (the specified style `"foo"` has higher precedence).
///
/// A [mark style property](https://vega.github.io/vega-lite/docs/config.html#style) to apply
/// to the title text mark.
///
/// __Default value:__ `"group-title"`.
///
/// Placeholder text if the `text` channel is not specified
///
/// The subtitle Text.
///
/// A string or array of strings indicating the name of custom styles to apply to the view
/// background. A style is a named collection of mark property defaults defined within the
/// [style configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If
/// style is an array, later styles will override earlier styles.
///
/// __Default value:__ `"cell"` __Note:__ Any specified view background properties will
/// augment the default style.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum RangeText {
    String(String),
    StringArray(Vec<String>),
}

/// Scale configuration determines default properties for all
/// [scales](https://vega.github.io/vega-lite/docs/scale.html). For a full list of scale
/// configuration options, please see the [corresponding section of the scale
/// documentation](https://vega.github.io/vega-lite/docs/scale.html#config).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleConfig {
    /// Default animation duration (in seconds) for time encodings, except for
    /// [`band`](https://vega.github.io/vega-lite/docs/scale.html#band) scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub animation_duration: Option<f64>,
    /// Default inner padding for `x` and `y` band scales.
    ///
    /// __Default value:__
    /// - `nestedOffsetPaddingInner` for x/y scales with nested x/y offset scales.
    /// - `barBandPaddingInner` for bar marks (`0.1` by default)
    /// - `rectBandPaddingInner` for rect and other marks (`0` by default)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_padding_inner: Option<CornerRadiusUnion>,
    /// Default outer padding for `x` and `y` band scales.
    ///
    /// __Default value:__ `paddingInner/2` (which makes _width/height = number of unique values
    /// * step_)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_padding_outer: Option<CornerRadiusUnion>,
    /// Default inner padding for `x` and `y` band scales with nested `xOffset` and `yOffset`
    /// encoding.
    ///
    /// __Default value:__ `0.2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_with_nested_offset_padding_inner: Option<CornerRadiusUnion>,
    /// Default outer padding for `x` and `y` band scales with nested `xOffset` and `yOffset`
    /// encoding.
    ///
    /// __Default value:__ `0.2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_with_nested_offset_padding_outer: Option<CornerRadiusUnion>,
    /// Default inner padding for `x` and `y` band-ordinal scales of `"bar"` marks.
    ///
    /// __Default value:__ `0.1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bar_band_padding_inner: Option<CornerRadiusUnion>,
    /// If true, values that exceed the data domain are clamped to either the minimum or maximum
    /// range value
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clamp: Option<Aria>,
    /// Default padding for continuous x/y scales.
    ///
    /// __Default:__ The bar width for continuous x-scale of a vertical bar and continuous
    /// y-scale of a horizontal bar.; `0` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_padding: Option<CornerRadiusUnion>,
    /// Default framerate (frames per second) for time
    /// [`band`](https://vega.github.io/vega-lite/docs/scale.html#band) scales.
    ///
    /// __Default value:__ `2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub frames_per_second: Option<f64>,
    /// An object that defines scale outputs per channel for invalid values (nulls and NaNs on a
    /// continuous scale).
    /// - The keys in this object are the scale channels.
    /// - The values is either `"zero-or-min"` (use zero if the scale includes zero or min value
    /// otherwise) or a value definition `{value: ...}`.
    ///
    /// _Example:_ Setting this `config.scale.invalid` property to `{color: {value: '#aaa'}}`
    /// will make the visualization color all invalid values with '#aaa'.
    ///
    /// See [https://vega.github.io/vega-lite/docs/invalid-data.html](Invalid Data Docs) for more
    /// details.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<ScaleInvalidDataConfig>,
    /// The default max value for mapping quantitative fields to bar's size/bandSize.
    ///
    /// If undefined (default), we will use the axis's size (width or height) - 1.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_band_size: Option<f64>,
    /// The default max value for mapping quantitative fields to text's size/fontSize scale.
    ///
    /// __Default value:__ `40`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_font_size: Option<f64>,
    /// Default max opacity for mapping a field to opacity.
    ///
    /// __Default value:__ `0.8`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_opacity: Option<f64>,
    /// Default max value for point size scale.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_size: Option<f64>,
    /// Default max strokeWidth for the scale of strokeWidth for rule and line marks and of size
    /// for trail marks.
    ///
    /// __Default value:__ `4`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_stroke_width: Option<f64>,
    /// The default min value for mapping quantitative fields to bar and tick's size/bandSize
    /// scale.
    ///
    /// __Default value:__ `2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<f64>,
    /// The default min value for mapping quantitative fields to text's size/fontSize scale.
    ///
    /// __Default value:__ `8`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_font_size: Option<f64>,
    /// Default minimum opacity for mapping a field to opacity.
    ///
    /// __Default value:__ `0.3`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_opacity: Option<f64>,
    /// Default minimum value for point size scale.
    ///
    /// __Default value:__ `9`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_size: Option<f64>,
    /// Default minimum strokeWidth for the scale of strokeWidth for rule and line marks and of
    /// size for trail marks.
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_stroke_width: Option<f64>,
    /// Default padding inner for xOffset/yOffset's band scales.
    ///
    /// __Default Value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset_band_padding_inner: Option<CornerRadiusUnion>,
    /// Default padding outer for xOffset/yOffset's band scales.
    ///
    /// __Default Value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset_band_padding_outer: Option<CornerRadiusUnion>,
    /// Default outer padding for `x` and `y` point-ordinal scales.
    ///
    /// __Default value:__ `0.5` (which makes _width/height = number of unique values * step_)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point_padding: Option<CornerRadiusUnion>,
    /// Default range cardinality for
    /// [`quantile`](https://vega.github.io/vega-lite/docs/scale.html#quantile) scale.
    ///
    /// __Default value:__ `4`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quantile_count: Option<f64>,
    /// Default range cardinality for
    /// [`quantize`](https://vega.github.io/vega-lite/docs/scale.html#quantize) scale.
    ///
    /// __Default value:__ `4`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub quantize_count: Option<f64>,
    /// Default inner padding for `x` and `y` band-ordinal scales of `"rect"` marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub rect_band_padding_inner: Option<CornerRadiusUnion>,
    /// If true, rounds numeric output values to integers. This can be helpful for snapping to
    /// the pixel grid. (Only available for `x`, `y`, and `size` scales.)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub round: Option<Aria>,
    /// Default inner padding for `x` and `y` band-ordinal scales of `"tick"` marks.
    ///
    /// __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_band_padding_inner: Option<CornerRadiusUnion>,
    /// Use the source data range before aggregation as scale domain instead of aggregated data
    /// for aggregate axis.
    ///
    /// This is equivalent to setting `domain` to `"unaggregate"` for aggregated _quantitative_
    /// fields by default.
    ///
    /// This property only works with aggregate functions that produce values within the raw data
    /// domain (`"mean"`, `"average"`, `"median"`, `"q1"`, `"q3"`, `"min"`, `"max"`). For other
    /// aggregations that produce values outside of the raw data domain (e.g. `"count"`,
    /// `"sum"`), this property is ignored.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub use_unaggregated_domain: Option<bool>,
    /// Reverse x-scale by default (useful for right-to-left charts).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_reverse: Option<Aria>,
    /// Default `scale.zero` for
    /// [`continuous`](https://vega.github.io/vega-lite/docs/scale.html#continuous) scales except
    /// for (1) x/y-scales of non-ranged bar or area charts and (2) size scales.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zero: Option<bool>,
}

/// An object that defines scale outputs per channel for invalid values (nulls and NaNs on a
/// continuous scale).
/// - The keys in this object are the scale channels.
/// - The values is either `"zero-or-min"` (use zero if the scale includes zero or min value
/// otherwise) or a value definition `{value: ...}`.
///
/// _Example:_ Setting this `config.scale.invalid` property to `{color: {value: '#aaa'}}`
/// will make the visualization color all invalid values with '#aaa'.
///
/// See [https://vega.github.io/vega-lite/docs/invalid-data.html](Invalid Data Docs) for more
/// details.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<ScaleInvalidDataShowAsAngle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<ScaleInvalidDataShowAsColor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<ScaleInvalidDataShowAsFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<ScaleInvalidDataShowAsFillOpacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<ScaleInvalidDataShowAsOpacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<ScaleInvalidDataShowAsRadius>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<ScaleInvalidDataShowAsShape>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<ScaleInvalidDataShowAsSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<ScaleInvalidDataShowAsStroke>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<ScaleInvalidDataShowAsStrokeDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<ScaleInvalidDataShowAsStrokeOpacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<ScaleInvalidDataShowAsStrokeWidth>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<ScaleInvalidDataShowAsTheta>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<ScaleInvalidDataShowAsTime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<ScaleInvalidDataShowAsX>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x_offset: Option<ScaleInvalidDataShowAsXOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<ScaleInvalidDataShowAsY>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y_offset: Option<ScaleInvalidDataShowAsYOffset>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsAngle {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueAngle(ScaleInvalidDataShowAsValueAngle),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueAngle {
    /// The rotation angle of the text, in degrees.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ScaleInvalidDataShowAs {
    #[serde(rename = "zero-or-min")]
    ZeroOrMin,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsColor {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueColor(ScaleInvalidDataShowAsValueColor),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueColor {
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ScaleInvalidDataShowAsValueColorValue>,
}

/// Default color.
///
/// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
///
/// __Note:__
/// - This property cannot be used in a [style
/// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
/// - The `fill` and `stroke` properties have higher precedence than `color` and will
/// override `color`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsValueColorValue {
    PurpleGradient(PurpleGradient),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PurpleGradient {
    /// The type of gradient. Use `"linear"` for a linear gradient.
    ///
    /// The type of gradient. Use `"radial"` for a radial gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient: Option<Gradient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<String>,
    /// An array of gradient stops defining the gradient color sequence.
    pub stops: Vec<GradientStop>,
    /// The starting x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x1: Option<f64>,
    /// The ending x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `1`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<f64>,
    /// The starting y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y1: Option<f64>,
    /// The ending y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the inner circle for the
    /// gradient.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r1: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the outer circle for the
    /// gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r2: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsFill {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueFill(ScaleInvalidDataShowAsValueFill),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueFill {
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ScaleInvalidDataShowAsValueFillValue>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsValueFillValue {
    FluffyGradient(FluffyGradient),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FluffyGradient {
    /// The type of gradient. Use `"linear"` for a linear gradient.
    ///
    /// The type of gradient. Use `"radial"` for a radial gradient.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub gradient: Option<Gradient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub id: Option<String>,
    /// An array of gradient stops defining the gradient color sequence.
    pub stops: Vec<GradientStop>,
    /// The starting x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x1: Option<f64>,
    /// The ending x-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `1`
    ///
    /// The x-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<f64>,
    /// The starting y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the inner circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y1: Option<f64>,
    /// The ending y-coordinate, in normalized [0, 1] coordinates, of the linear gradient.
    ///
    /// __Default value:__ `0`
    ///
    /// The y-coordinate, in normalized [0, 1] coordinates, for the center of the outer circle
    /// for the gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the inner circle for the
    /// gradient.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r1: Option<f64>,
    /// The radius length, in normalized [0, 1] coordinates, of the outer circle for the
    /// gradient.
    ///
    /// __Default value:__ `0.5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub r2: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsFillOpacity {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueFillOpacity(ScaleInvalidDataShowAsValueFillOpacity),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueFillOpacity {
    /// The fill opacity (value between [0,1]).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsOpacity {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueOpacity(ScaleInvalidDataShowAsValueOpacity),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueOpacity {
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsRadius {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueRadius(ScaleInvalidDataShowAsValueRadius),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueRadius {
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsShape {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueShape(ScaleInvalidDataShowAsValueShape),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueShape {
    /// Shape of the point marks. Supported values include:
    /// - plotting shapes: `"circle"`, `"square"`, `"cross"`, `"diamond"`, `"triangle-up"`,
    /// `"triangle-down"`, `"triangle-right"`, or `"triangle-left"`.
    /// - the line symbol `"stroke"`
    /// - centered directional shapes `"arrow"`, `"wedge"`, or `"triangle"`
    /// - a custom [SVG path
    /// string](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths) (For correct
    /// sizing, custom shape paths should be defined within a square bounding box with
    /// coordinates ranging from -1 to 1 along both the x and y dimensions.)
    ///
    /// __Default value:__ `"circle"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsSize {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueSize(ScaleInvalidDataShowAsValueSize),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueSize {
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsStroke {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueStroke(ScaleInvalidDataShowAsValueStroke),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueStroke {
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ScaleInvalidDataShowAsValueFillValue>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsStrokeDash {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueStrokeDash(ScaleInvalidDataShowAsValueStrokeDash),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueStrokeDash {
    /// An array of alternating stroke, space lengths for creating dashed or dotted lines.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<Vec<f64>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsStrokeOpacity {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueStrokeOpacity(ScaleInvalidDataShowAsValueStrokeOpacity),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueStrokeOpacity {
    /// The stroke opacity (value between [0,1]).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsStrokeWidth {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueStrokeWidth(ScaleInvalidDataShowAsValueStrokeWidth),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueStrokeWidth {
    /// The stroke width, in pixels.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsTheta {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueTheta(ScaleInvalidDataShowAsValueTheta),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueTheta {
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsTime {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueTime(ScaleInvalidDataShowAsValueTime),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueTime {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsX {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueX(ScaleInvalidDataShowAsValueX),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueX {
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ScaleInvalidDataShowAsValueXValue>,
}

/// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
/// `x2` or `width`.
///
/// The `value` of this channel can be a number or a string `"width"` for the width of the
/// plot.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsValueXValue {
    Double(f64),
    Enum(XEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsXOffset {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueXOffset(ScaleInvalidDataShowAsValueXOffset),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueXOffset {
    /// Offset for x-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsY {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueY(ScaleInvalidDataShowAsValueY),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueY {
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<ScaleInvalidDataShowAsValueYValue>,
}

/// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
/// `y2` or `height`.
///
/// The `value` of this channel can be a number or a string `"height"` for the height of the
/// plot.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsValueYValue {
    Double(f64),
    Enum(YEnum),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum ScaleInvalidDataShowAsYOffset {
    Enum(ScaleInvalidDataShowAs),
    ScaleInvalidDataShowAsValueYOffset(ScaleInvalidDataShowAsValueYOffset),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ScaleInvalidDataShowAsValueYOffset {
    /// Offset for y-position.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub value: Option<f64>,
}

/// An object hash for defining default properties for each type of selections.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct SelectionClass {
    /// The default definition for an
    /// [`interval`](https://vega.github.io/vega-lite/docs/parameter.html#select) selection. All
    /// properties and transformations for an interval selection definition (except `type`) may
    /// be specified here.
    ///
    /// For instance, setting `interval` to `{"translate": false}` disables the ability to move
    /// interval selections by default.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interval: Option<IntervalSelectionConfigWithoutType>,
    /// The default definition for a
    /// [`point`](https://vega.github.io/vega-lite/docs/parameter.html#select) selection. All
    /// properties and transformations  for a point selection definition (except `type`) may be
    /// specified here.
    ///
    /// For instance, setting `point` to `{"on": "dblclick"}` populates point selections on
    /// double-click by default.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<PointSelectionConfigWithoutType>,
}

/// The default definition for an
/// [`interval`](https://vega.github.io/vega-lite/docs/parameter.html#select) selection. All
/// properties and transformations for an interval selection definition (except `type`) may
/// be specified here.
///
/// For instance, setting `interval` to `{"translate": false}` disables the ability to move
/// interval selections by default.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct IntervalSelectionConfigWithoutType {
    /// Clears the selection, emptying it of all values. This property can be a [Event
    /// Stream](https://vega.github.io/vega/docs/event-streams/) or `false` to disable clear.
    ///
    /// __Default value:__ `dblclick`.
    ///
    /// __See also:__ [`clear` examples
    /// ](https://vega.github.io/vega-lite/docs/selection.html#clear) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clear: Option<ClearUnion>,
    /// An array of encoding channels. The corresponding data field values must match for a data
    /// tuple to fall within the selection.
    ///
    /// __See also:__ The [projection with `encodings` and `fields`
    /// section](https://vega.github.io/vega-lite/docs/selection.html#project) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encodings: Option<Vec<SingleDefUnitChannel>>,
    /// An array of field names whose values must match for a data tuple to fall within the
    /// selection.
    ///
    /// __See also:__ The [projection with `encodings` and `fields`
    /// section](https://vega.github.io/vega-lite/docs/selection.html#project) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fields: Option<Vec<String>>,
    /// An interval selection also adds a rectangle mark to depict the extents of the interval.
    /// The `mark` property can be used to customize the appearance of the mark.
    ///
    /// __See also:__ [`mark`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#mark) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<BrushConfig>,
    /// A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
    /// selector) that triggers the selection. For interval selections, the event stream must
    /// specify a [start and
    /// end](https://vega.github.io/vega/docs/event-streams/#between-filters).
    ///
    /// __See also:__ [`on` examples](https://vega.github.io/vega-lite/docs/selection.html#on) in
    /// the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub on: Option<OnUnion>,
    /// With layered and multi-view displays, a strategy that determines how selections' data
    /// queries are resolved when applied in a filter transform, conditional encoding rule, or
    /// scale domain.
    ///
    /// One of:
    /// - `"global"` -- only one brush exists for the entire SPLOM. When the user begins to drag,
    /// any previous brushes are cleared, and a new one is constructed.
    /// - `"union"` -- each cell contains its own brush, and points are highlighted if they lie
    /// within _any_ of these individual brushes.
    /// - `"intersect"` -- each cell contains its own brush, and points are highlighted only if
    /// they fall within _all_ of these individual brushes.
    ///
    /// __Default value:__ `global`.
    ///
    /// __See also:__ [`resolve`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#resolve) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<SelectionResolution>,
    /// When truthy, allows a user to interactively move an interval selection back-and-forth.
    /// Can be `true`, `false` (to disable panning), or a [Vega event stream
    /// definition](https://vega.github.io/vega/docs/event-streams/) which must include a start
    /// and end event to trigger continuous panning. Discrete panning (e.g., pressing the
    /// left/right arrow keys) will be supported in future versions.
    ///
    /// __Default value:__ `true`, which corresponds to `[pointerdown, window:pointerup] >
    /// window:pointermove!`. This default allows users to clicks and drags within an interval
    /// selection to reposition it.
    ///
    /// __See also:__ [`translate`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#translate) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub translate: Option<Toggle>,
    /// When truthy, allows a user to interactively resize an interval selection. Can be `true`,
    /// `false` (to disable zooming), or a [Vega event stream
    /// definition](https://vega.github.io/vega/docs/event-streams/). Currently, only `wheel`
    /// events are supported, but custom event streams can still be used to specify filters,
    /// debouncing, and throttling. Future versions will expand the set of events that can
    /// trigger this transformation.
    ///
    /// __Default value:__ `true`, which corresponds to `wheel!`. This default allows users to
    /// use the mouse wheel to resize an interval selection.
    ///
    /// __See also:__ [`zoom`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#zoom) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zoom: Option<Toggle>,
}

/// The default definition for a
/// [`point`](https://vega.github.io/vega-lite/docs/parameter.html#select) selection. All
/// properties and transformations  for a point selection definition (except `type`) may be
/// specified here.
///
/// For instance, setting `point` to `{"on": "dblclick"}` populates point selections on
/// double-click by default.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct PointSelectionConfigWithoutType {
    /// Clears the selection, emptying it of all values. This property can be a [Event
    /// Stream](https://vega.github.io/vega/docs/event-streams/) or `false` to disable clear.
    ///
    /// __Default value:__ `dblclick`.
    ///
    /// __See also:__ [`clear` examples
    /// ](https://vega.github.io/vega-lite/docs/selection.html#clear) in the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clear: Option<ClearUnion>,
    /// An array of encoding channels. The corresponding data field values must match for a data
    /// tuple to fall within the selection.
    ///
    /// __See also:__ The [projection with `encodings` and `fields`
    /// section](https://vega.github.io/vega-lite/docs/selection.html#project) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encodings: Option<Vec<SingleDefUnitChannel>>,
    /// An array of field names whose values must match for a data tuple to fall within the
    /// selection.
    ///
    /// __See also:__ The [projection with `encodings` and `fields`
    /// section](https://vega.github.io/vega-lite/docs/selection.html#project) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fields: Option<Vec<String>>,
    /// When true, an invisible voronoi diagram is computed to accelerate discrete selection. The
    /// data value _nearest_ the mouse cursor is added to the selection.
    ///
    /// __Default value:__ `false`, which means that data values must be interacted with directly
    /// (e.g., clicked on) to be added to the selection.
    ///
    /// __See also:__ [`nearest`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#nearest) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub nearest: Option<bool>,
    /// A [Vega event stream](https://vega.github.io/vega/docs/event-streams/) (object or
    /// selector) that triggers the selection. For interval selections, the event stream must
    /// specify a [start and
    /// end](https://vega.github.io/vega/docs/event-streams/#between-filters).
    ///
    /// __See also:__ [`on` examples](https://vega.github.io/vega-lite/docs/selection.html#on) in
    /// the documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub on: Option<OnUnion>,
    /// With layered and multi-view displays, a strategy that determines how selections' data
    /// queries are resolved when applied in a filter transform, conditional encoding rule, or
    /// scale domain.
    ///
    /// One of:
    /// - `"global"` -- only one brush exists for the entire SPLOM. When the user begins to drag,
    /// any previous brushes are cleared, and a new one is constructed.
    /// - `"union"` -- each cell contains its own brush, and points are highlighted if they lie
    /// within _any_ of these individual brushes.
    /// - `"intersect"` -- each cell contains its own brush, and points are highlighted only if
    /// they fall within _all_ of these individual brushes.
    ///
    /// __Default value:__ `global`.
    ///
    /// __See also:__ [`resolve`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#resolve) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<SelectionResolution>,
    /// Controls whether data values should be toggled (inserted or removed from a point
    /// selection) or only ever inserted into point selections.
    ///
    /// One of:
    /// - `true` -- the default behavior, which corresponds to `"event.shiftKey"`.  As a result,
    /// data values are toggled when the user interacts with the shift-key pressed.
    /// - `false` -- disables toggling behaviour; the selection will only ever contain a single
    /// data value corresponding to the most recent interaction.
    /// - A [Vega expression](https://vega.github.io/vega/docs/expressions/) which is
    /// re-evaluated as the user interacts. If the expression evaluates to `true`, the data value
    /// is toggled into or out of the point selection. If the expression evaluates to `false`,
    /// the point selection is first cleared, and the data value is then inserted. For example,
    /// setting the value to the Vega expression `"true"` will toggle data values without the
    /// user pressing the shift-key.
    ///
    /// __Default value:__ `true`
    ///
    /// __See also:__ [`toggle`
    /// examples](https://vega.github.io/vega-lite/docs/selection.html#toggle) in the
    /// documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub toggle: Option<Toggle>,
}

/// Arc-specific Config
///
/// Image-specific Config
///
/// Rect-Specific Config
///
/// Area-Specific Config
///
/// Bar-Specific Config
///
/// Circle-Specific Config
///
/// Geoshape-Specific Config
///
/// Mark Config
///
/// Point-Specific Config
///
/// Rule-Specific Config
///
/// Square-Specific Config
///
/// Default style for chart subtitles
///
/// Default style for chart titles
///
/// Default style for axis, legend, and header labels.
///
/// Default style for axis, legend, and header titles.
///
/// Text-Specific Config
///
/// Line-Specific Config
///
/// Trail-Specific Config
///
/// Tick-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct StyleValue {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    /// Offset between bars for binned field. The ideal value for this is either 0 (preferred by
    /// statisticians) or 1 (Vega-Lite default, D3 example style).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin_spacing: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    /// The default size of the bars on continuous scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_band_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    /// The default size of the bars with discrete dimensions. If unspecified, the default size
    /// is  `step-2`, which provides 2 pixel offset between bars.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_band_size: Option<DiscreteBandSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The minimum band size for bar and rectangle marks. __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    ///
    /// The orientation of the axis. One of `"top"`, `"bottom"`, `"left"` or `"right"`. The
    /// orientation can be used to further specialize the axis type (e.g., a y-axis oriented
    /// towards the right edge of the chart).
    ///
    /// __Default value:__ `"bottom"` for x-axes and `"left"` for y-axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<StyleOrient>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    /// Text-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
    /// A flag for overlaying line on top of area marks, or an object defining the properties of
    /// the overlayed lines.
    ///
    /// - If this value is an empty object (`{}`) or `true`, lines with default properties will
    /// be used.
    ///
    /// - If this value is `false`, no lines would be automatically added to area marks.
    ///
    /// __Default value:__ `false`.
    ///
    /// Line-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line: Option<Line>,
    /// A flag for overlaying points on top of line or area marks, or an object defining the
    /// properties of the overlayed points.
    ///
    /// - If this property is `"transparent"`, transparent points will be used (for enhancing
    /// tooltips and selections).
    ///
    /// - If this property is an empty object (`{}`) or `true`, filled points with default
    /// properties will be used.
    ///
    /// - If this property is `false`, no points would be automatically added to line or area
    /// marks.
    ///
    /// __Default value:__ `false`.
    ///
    /// Point-Specific Config
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub point: Option<PointUnion>,
    /// - For vertical bars, top-left and top-right corner radius.
    ///
    /// - For horizontal bars, top-right and bottom-right corner radius.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_end: Option<CornerRadiusUnion>,
    /// The width of the ticks.
    ///
    /// __Default value:__  3/4 of step (width step for horizontal ticks and height step for
    /// vertical ticks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_size: Option<f64>,
    /// Thickness of the tick mark.
    ///
    /// __Default value:__  `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub thickness: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_position: Option<CornerRadiusUnion>,
    /// A boolean flag indicating if the domain (the axis baseline) should be included as part of
    /// the axis.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub domain_width: Option<CornerRadiusUnion>,
    /// When used with the default `"number"` and `"time"` format type, the text formatting
    /// pattern for labels of guides (axes, legends, headers) and text marks.
    ///
    /// - If the format type is `"number"` (e.g., for quantitative fields), this is D3's [number
    /// format pattern](https://github.com/d3/d3-format#locale_format).
    /// - If the format type is `"time"` (e.g., for temporal fields), this is D3's [time format
    /// pattern](https://github.com/d3/d3-time-format#locale_format).
    ///
    /// See the [format documentation](https://vega.github.io/vega-lite/docs/format.html) for
    /// more examples.
    ///
    /// When used with a [custom
    /// `formatType`](https://vega.github.io/vega-lite/docs/config.html#custom-format-type), this
    /// value will be passed as `format` alongside `datum.value` to the registered function.
    ///
    /// __Default value:__  Derived from
    /// [numberFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for
    /// number format and from
    /// [timeFormat](https://vega.github.io/vega-lite/docs/config.html#format) config for time
    /// format.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format: Option<Format>,
    /// The format type for labels. One of `"number"`, `"time"`, or a [registered custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type).
    ///
    /// __Default value:__
    /// - `"time"` for temporal fields and ordinal and nominal fields with `timeUnit`.
    /// - `"number"` for quantitative fields as well as ordinal and nominal fields without
    /// `timeUnit`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub format_type: Option<String>,
    /// A boolean flag indicating if grid lines should be included as part of the axis
    ///
    /// __Default value:__ `true` for [continuous
    /// scales](https://vega.github.io/vega-lite/docs/scale.html#continuous) that are not binned;
    /// otherwise, `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_color: Option<GridColorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_dash: Option<AxisGridDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_dash_offset: Option<GridDashOffsetUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_opacity: Option<GridOpacityUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub grid_width: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_align: Option<ConditionalAxisPropertyAlignNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_angle: Option<LabelAngle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_baseline: Option<PurpleTextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_bound: Option<Label>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_color: Option<GridColorUnion>,
    /// [Vega expression](https://vega.github.io/vega/docs/expressions/) for customizing labels.
    ///
    /// __Note:__ The label text and value can be assessed via the `label` and `value` properties
    /// of the axis's backing `datum` object.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_expr: Option<String>,
    /// Indicates if the first and last axis labels should be aligned flush with the scale range.
    /// Flush alignment for a horizontal axis will left-align the first label and right-align the
    /// last label. For vertical axes, bottom and top text baselines are applied instead. If this
    /// property is a number, it also indicates the number of pixels by which to offset the first
    /// and last labels; for example, a value of 2 will flush-align the first and last labels and
    /// also push them 2 pixels outward from the center of the axis. The additional adjustment
    /// can sometimes help the labels better visually group with corresponding axis ticks.
    ///
    /// __Default value:__ `true` for axis of a continuous x-scale. Otherwise, `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_flush: Option<LabelFlush>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_flush_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font: Option<ConditionalAxisPropertyStringNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_size: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_style: Option<ConditionalAxisPropertyFontStyleNull>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_font_weight: Option<FontWeight>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_offset: Option<GridDashOffsetUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_opacity: Option<GridDashOffsetUnion>,
    /// The strategy to use for resolving overlap of axis labels. If `false` (the default), no
    /// overlap reduction is attempted. If set to `true` or `"parity"`, a strategy of removing
    /// every other label is used (this works well for standard linear axes). If set to
    /// `"greedy"`, a linear scan of the labels is performed, removing any labels that overlaps
    /// with the last visible label (this often works better for log-scaled axes).
    ///
    /// __Default value:__ `true` for non-nominal fields with non-log scales; `"greedy"` for log
    /// scales; otherwise `false`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_overlap: Option<LabelOverlapUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_padding: Option<GridDashOffsetUnion>,
    /// A boolean flag indicating if labels should be included as part of the axis.
    ///
    /// __Default value:__ `true`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub labels: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub label_separation: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub max_extent: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_extent: Option<CornerRadiusUnion>,
    /// The offset, in pixels, by which to displace the axis from the edge of the enclosing group
    /// or data rectangle.
    ///
    /// __Default value:__ derived from the [axis
    /// config](https://vega.github.io/vega-lite/docs/config.html#facet-scale-config)'s `offset`
    /// (`0` by default)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    /// The anchor position of the axis in pixels. For x-axes with top or bottom orientation,
    /// this sets the axis group x coordinate. For y-axes with left or right orientation, this
    /// sets the axis group y coordinate.
    ///
    /// __Default value__: `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub position: Option<CornerRadiusUnion>,
    /// A string or array of strings indicating the name of custom styles to apply to the axis. A
    /// style is a named collection of axis property defined within the [style
    /// configuration](https://vega.github.io/vega-lite/docs/mark.html#style-config). If style is
    /// an array, later styles will override earlier styles.
    ///
    /// __Default value:__ (none) __Note:__ Any specified style will augment the default style.
    /// For example, an x-axis mark with `"style": "foo"` will use `config.axisX` and
    /// `config.style.foo` (the specified style `"foo"` has higher precedence).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub style: Option<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_band: Option<TickBandUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_color: Option<GridColorUnion>,
    /// A desired number of ticks, for axes visualizing quantitative scales. The resulting number
    /// may be different so that values are "nice" (multiples of 2, 5, 10) and lie within the
    /// underlying scale's range.
    ///
    /// For scales of type `"time"` or `"utc"`, the tick count can instead be a time interval
    /// specifier. Legal string values are `"millisecond"`, `"second"`, `"minute"`, `"hour"`,
    /// `"day"`, `"week"`, `"month"`, and `"year"`. Alternatively, an object-valued interval
    /// specifier of the form `{"interval": "month", "step": 3}` includes a desired number of
    /// interval steps. Here, ticks are generated for each quarter (Jan, Apr, Jul, Oct)
    /// boundary.
    ///
    /// __Default value__: Determine using a formula `ceil(width/40)` for x and `ceil(height/40)`
    /// for y.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_count: Option<TickCount>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_dash: Option<AxisTickDash>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_dash_offset: Option<GridDashOffsetUnion>,
    /// Boolean flag indicating if an extra axis tick should be added for the initial position of
    /// the axis. This flag is useful for styling axes for `band` scales such that ticks are
    /// placed on band boundaries rather in the middle of a band. Use in conjunction with
    /// `"bandPosition": 1` and an axis `"padding"` value of `0`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_extra: Option<bool>,
    /// The minimum desired step between axis ticks, in terms of scale domain values. For
    /// example, a value of `1` indicates that ticks should not be less than 1 unit apart. If
    /// `tickMinStep` is specified, the `tickCount` value will be adjusted, if necessary, to
    /// enforce the minimum step value.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_min_step: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_opacity: Option<GridDashOffsetUnion>,
    /// Boolean flag indicating if pixel position values should be rounded to the nearest
    /// integer.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_round: Option<bool>,
    /// Boolean value that determines whether the axis should include ticks.
    ///
    /// __Default value:__ `true`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ticks: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_size: Option<GridWidthUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tick_width: Option<GridWidthUnion>,
    /// A title for the field. If `null`, the title will be removed.
    ///
    /// __Default value:__  derived from the field's name and transformation function
    /// (`aggregate`, `bin` and `timeUnit`). If the field has an aggregate function, the function
    /// is displayed as part of the title (e.g., `"Sum of Profit"`). If the field is binned or
    /// has a time unit applied, the applied function is shown in parentheses (e.g., `"Profit
    /// (binned)"`, `"Transaction Date (year-month)"`). Otherwise, the title is simply the field
    /// name.
    ///
    /// __Notes__:
    ///
    /// 1) You can customize the default field title format by providing the
    /// [`fieldTitle`](https://vega.github.io/vega-lite/docs/config.html#top-level-config)
    /// property in the [config](https://vega.github.io/vega-lite/docs/config.html) or
    /// [`fieldTitle` function via the `compile` function's
    /// options](https://vega.github.io/vega-lite/usage/compile.html#field-title).
    ///
    /// 2) If both field definition's `title` and axis, header, or legend `title` are defined,
    /// axis/header/legend title will be used.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub title: RemovableValue<LegendText>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_anchor: Option<TitleAnchorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_angle: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_baseline: Option<TextBaseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_opacity: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_x: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title_y: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub translate: Option<CornerRadiusUnion>,
    /// Explicitly set the visible axis tick values.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub values: Option<Values>,
    /// A non-negative integer indicating the z-index of the axis. If zindex is 0, axes should be
    /// drawn behind all chart elements. To put them in front, set `zindex` to `1` or more.
    ///
    /// __Default value:__ `0` (behind the marks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum StyleOrient {
    BackgroundExprRef(BackgroundExprRef),
    Enum(AxisOrient),
}

/// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
/// horizontal (default) or vertical.
/// - For bar, rule and tick, this determines whether the size of the bar and tick should be
/// applied to x or y dimension.
/// - For area, this property determines the orient property of the Vega output.
/// - For line and trail marks, this property determines the sort order of the points in the
/// line if `config.sortLineBy` is not specified. For stacked charts, this is always
/// determined by the orientation of the stack; therefore explicitly specified value will be
/// ignored.
///
/// The direction of the legend, one of `"vertical"` or `"horizontal"`.
///
/// __Default value:__
/// - For top-/bottom-`orient`ed legends, `"horizontal"`
/// - For left-/right-`orient`ed legends, `"vertical"`
/// - For top/bottom-left/right-`orient`ed legends, `"horizontal"` for gradient legends and
/// `"vertical"` for symbol legends.
///
/// The default direction (`"horizontal"` or `"vertical"`) for gradient legends.
///
/// __Default value:__ `"vertical"`.
///
/// The default direction (`"horizontal"` or `"vertical"`) for symbol legends.
///
/// __Default value:__ `"vertical"`.
///
/// Orientation of the box plot. This is normally automatically determined based on types of
/// fields on x and y channels. However, an explicit `orient` be specified when the
/// orientation is ambiguous.
///
/// __Default value:__ `"vertical"`.
///
/// Orientation of the error bar. This is normally automatically determined, but can be
/// specified when the orientation is ambiguous and cannot be automatically determined.
///
/// Orientation of the error band. This is normally automatically determined, but can be
/// specified when the orientation is ambiguous and cannot be automatically determined.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AxisOrient {
    Bottom,
    Horizontal,
    Left,
    Right,
    Top,
    Vertical,
}

/// Tick-Specific Config
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct TickConfig {
    /// The horizontal alignment of the text or ranged marks (area, bar, image, rect, rule). One
    /// of `"left"`, `"right"`, `"center"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<TitleAlignUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<Angle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria_role_description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aspect: Option<Aria>,
    /// The width of the ticks.
    ///
    /// __Default value:__  3/4 of step (width step for horizontal ticks and height step for
    /// vertical ticks).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub band_size: Option<f64>,
    /// For text marks, the vertical text baseline. One of `"alphabetic"` (default), `"top"`,
    /// `"middle"`, `"bottom"`, `"line-top"`, `"line-bottom"`, or an expression reference that
    /// provides one of the valid values. The `"line-top"` and `"line-bottom"` values operate
    /// similarly to `"top"` and `"bottom"`, but are calculated relative to the `lineHeight`
    /// rather than `fontSize` alone.
    ///
    /// For range marks, the vertical alignment of the marks. One of `"top"`, `"middle"`,
    /// `"bottom"`.
    ///
    /// __Note:__ Expression reference is *not* supported for range marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<TextBaseline>,
    /// Offset between bars for binned field. The ideal value for this is either 0 (preferred by
    /// statisticians) or 1 (Vega-Lite default, D3 example style).
    ///
    /// __Default value:__ `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bin_spacing: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub blend: Option<BlendUnion>,
    /// Default color.
    ///
    /// __Default value:__ <span style="color: #4682b4;">&#9632;</span> `"#4682b4"`
    ///
    /// __Note:__
    /// - This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    /// - The `fill` and `stroke` properties have higher precedence than `color` and will
    /// override `color`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<MarkConfigColor>,
    /// The default size of the bars on continuous scales.
    ///
    /// __Default value:__ `5`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_band_size: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_bottom_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_left: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius_top_right: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<CursorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dir: Option<Dir>,
    /// The default size of the bars with discrete dimensions. If unspecified, the default size
    /// is  `step-2`, which provides 2 pixel offset between bars.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_band_size: Option<DiscreteBandSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub ellipsis: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub end_angle: Option<CornerRadiusUnion>,
    /// Default fill color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove fill.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<MarkConfigFill>,
    /// Whether the mark's color should be used as fill color instead of stroke color.
    ///
    /// __Default value:__ `false` for all `point`, `line`, and `rule` marks as well as
    /// `geoshape` marks for
    /// [`graticule`](https://vega.github.io/vega-lite/docs/data.html#graticule) data sources;
    /// otherwise, `true`.
    ///
    /// __Note:__ This property cannot be used in a [style
    /// config](https://vega.github.io/vega-lite/docs/mark.html#style-config).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub filled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub href: Option<Box<Color>>,
    /// The inner radius in pixels of arc marks. `innerRadius` is an alias for `radius2`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub inner_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub interpolate: Option<MarkConfigInterpolate>,
    /// Invalid data mode, which defines how the marks and corresponding scales should represent
    /// invalid values (`null` and `NaN` in continuous scales *without* defined output for
    /// invalid values).
    ///
    /// - `"filter"` — *Exclude* all invalid values from the visualization's *marks* and
    /// *scales*. For path marks (for line, area, trail), this option will create paths that
    /// connect valid points, as if the data rows with invalid values do not exist.
    ///
    /// - `"break-paths-filter-domains"` — Break path marks (for line, area, trail) at invalid
    /// values.  For non-path marks, this is equivalent to `"filter"`. All *scale* domains will
    /// *exclude* these filtered data points.
    ///
    /// - `"break-paths-show-domains"` — Break paths (for line, area, trail) at invalid values.
    /// Hide invalid values for non-path marks. All *scale* domains will *include* these filtered
    /// data points (for both path and non-path marks).
    ///
    /// - `"show"` or `null` — Show all data points in the marks and scale domains. Each scale
    /// will use the output for invalid values defined in `config.scale.invalid` or, if
    /// unspecified, by default invalid values will produce the same visual values as zero (if
    /// the scale includes zero) or the minimum value (if the scale does not include zero).
    ///
    /// - `"break-paths-show-path-domains"` (default) — This is equivalent to
    /// `"break-paths-show-domains"` for path-based marks (line/area/trail) and `"filter"` for
    /// non-path marks.
    ///
    /// __Note__: If any channel's scale has an output for invalid values defined in
    /// `config.scale.invalid`, all values for the scales will be considered "valid" since they
    /// can produce a reasonable output for the scales. Thus, fields for such channels will not
    /// be filtered and will not cause path breaks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub invalid: Option<MarkInvalidDataMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_break: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    /// The minimum band size for bar and rectangle marks. __Default value:__ `0.25`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub min_band_size: Option<CornerRadiusUnion>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// For line and trail marks, this `order` property can be set to `null` or `false` to make
    /// the lines use the original order in the data sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub order: Option<bool>,
    /// The orientation of a non-stacked bar, tick, area, and line charts. The value is either
    /// horizontal (default) or vertical.
    /// - For bar, rule and tick, this determines whether the size of the bar and tick should be
    /// applied to x or y dimension.
    /// - For area, this property determines the orient property of the Vega output.
    /// - For line and trail marks, this property determines the sort order of the points in the
    /// line if `config.sortLineBy` is not specified. For stacked charts, this is always
    /// determined by the orientation of the stack; therefore explicitly specified value will be
    /// ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<Orientation>,
    /// The outer radius in pixels of arc marks. `outerRadius` is an alias for `radius`.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub outer_radius: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub pad_angle: Option<CornerRadiusUnion>,
    /// For arc mark, the primary (outer) radius in pixels.
    ///
    /// For text marks, polar coordinate radial offset, in pixels, of the text from the origin
    /// determined by the `x` and `y` properties.
    ///
    /// __Default value:__ `min(plot_width, plot_height)/2`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius: Option<CornerRadiusUnion>,
    /// The secondary (inner) radius in pixels of arc marks.
    ///
    /// __Default value:__ `0`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub radius2: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub shape: Option<Box<Color>>,
    /// Default size for marks.
    /// - For `point`/`circle`/`square`, this represents the pixel area of the marks. Note that
    /// this value sets the area of the symbol; the side lengths will increase with the square
    /// root of this value.
    /// - For `bar`, this represents the band size of the bar, in pixels.
    /// - For `text`, this represents the font size, in pixels.
    ///
    /// __Default value:__
    /// - `30` for point, circle, square marks; width/height's `step`
    /// - `2` for bar marks with discrete dimensions;
    /// - `5` for bar marks with continuous dimensions;
    /// - `11` for text marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub size: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub smooth: Option<Aria>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub start_angle: Option<CornerRadiusUnion>,
    /// Default stroke color. This property has higher precedence than `config.color`. Set to
    /// `null` to remove stroke.
    ///
    /// __Default value:__ (None)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke: Option<MarkConfigFill>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tension: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub text: Option<ConditionalPredicateValueDefTextExprRefText>,
    /// - For arc marks, the arc length in radians if theta2 is not specified, otherwise the
    /// start arc angle. (A value of 0 indicates up or “north”, increasing values proceed
    /// clockwise.)
    ///
    /// - For text marks, polar coordinate angle in radians.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta: Option<CornerRadiusUnion>,
    /// The end angle of arc marks in radians. A value of 0 indicates up or “north”, increasing
    /// values proceed clockwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub theta2: Option<CornerRadiusUnion>,
    /// Thickness of the tick mark.
    ///
    /// __Default value:__  `1`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub thickness: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time: Option<CornerRadiusUnion>,
    /// Default relative band position for a time unit. If set to `0`, the marks will be
    /// positioned at the beginning of the time unit band step. If set to `0.5`, the marks will
    /// be positioned in the middle of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_position: Option<f64>,
    /// Default relative band size for a time unit. If set to `1`, the bandwidth of the marks
    /// will be equal to the time unit band step. If set to `0.5`, bandwidth of the marks will be
    /// half of the time unit band step.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_unit_band_size: Option<f64>,
    /// The tooltip text string to show upon mouse hover or an object defining which fields
    /// should the tooltip be derived from.
    ///
    /// - If `tooltip` is `true` or `{"content": "encoding"}`, then all fields from `encoding`
    /// will be used.
    /// - If `tooltip` is `{"content": "data"}`, then all fields that appear in the highlighted
    /// data point will be used.
    /// - If set to `null` or `false`, then no tooltip will be used.
    ///
    /// See the [`tooltip`](https://vega.github.io/vega-lite/docs/tooltip.html) documentation for
    /// a detailed discussion about tooltip  in Vega-Lite.
    ///
    /// __Default value:__ `null`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub tooltip: Option<OverlayMarkDefTooltip>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub url: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<CornerRadiusUnion>,
    /// X coordinates of the marks, or width of horizontal `"bar"` and `"area"` without specified
    /// `x2` or `width`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x: Option<XUnion>,
    /// X2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"width"` for the width of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub x2: Option<XUnion>,
    /// Y coordinates of the marks, or height of vertical `"bar"` and `"area"` without specified
    /// `y2` or `height`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y: Option<YUnion>,
    /// Y2 coordinates for ranged `"area"`, `"bar"`, `"rect"`, and  `"rule"`.
    ///
    /// The `value` of this channel can be a number or a string `"height"` for the height of the
    /// plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub y2: Option<YUnion>,
}

/// Title configuration, which determines default properties for all
/// [titles](https://vega.github.io/vega-lite/docs/title.html). For a full list of title
/// configuration options, please see the [corresponding section of the title
/// documentation](https://vega.github.io/vega-lite/docs/title.html#config).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct BaseTitleNoValueRefs {
    /// Horizontal text alignment for title text. One of `"left"`, `"center"`, or `"right"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Align>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub anchor: Option<TitleAnchorUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub angle: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub aria: Option<Aria>,
    /// Vertical text baseline for title and subtitle text. One of `"alphabetic"` (default),
    /// `"top"`, `"middle"`, `"bottom"`, `"line-top"`, or `"line-bottom"`. The `"line-top"` and
    /// `"line-bottom"` values operate similarly to `"top"` and `"bottom"`, but are calculated
    /// relative to the *lineHeight* rather than *fontSize* alone.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub baseline: Option<Baseline>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dx: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub dy: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub frame: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub limit: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub orient: Option<TitleParamsOrient>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_color: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font_size: Option<FontSize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font_style: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_font_weight: Option<FontWeightUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_line_height: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub subtitle_padding: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub zindex: Option<FontSize>,
}

/// Define [custom format
/// configuration](https://vega.github.io/vega-lite/docs/config.html#format) for tooltips. If
/// unspecified, default format config will be applied.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct FormatConfig {
    /// If normalizedNumberFormatType is not specified, D3 number format for axis labels, text
    /// marks, and tooltips of normalized stacked fields (fields with `stack: "normalize"`). For
    /// example `"s"` for SI units. Use [D3's number format
    /// pattern](https://github.com/d3/d3-format#locale_format).
    ///
    /// If `config.normalizedNumberFormatType` is specified and `config.customFormatTypes` is
    /// `true`, this value will be passed as `format` alongside `datum.value` to the
    /// `config.numberFormatType` function. __Default value:__ `%`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub normalized_number_format: Option<String>,
    /// [Custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type) for
    /// `config.normalizedNumberFormat`.
    ///
    /// __Default value:__ `undefined` -- This is equilvalent to call D3-format, which is exposed
    /// as [`format` in Vega-Expression](https://vega.github.io/vega/docs/expressions/#format).
    /// __Note:__ You must also set `customFormatTypes` to `true` to use this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub normalized_number_format_type: Option<String>,
    /// If numberFormatType is not specified, D3 number format for guide labels, text marks, and
    /// tooltips of non-normalized fields (fields *without* `stack: "normalize"`). For example
    /// `"s"` for SI units. Use [D3's number format
    /// pattern](https://github.com/d3/d3-format#locale_format).
    ///
    /// If `config.numberFormatType` is specified and `config.customFormatTypes` is `true`, this
    /// value will be passed as `format` alongside `datum.value` to the `config.numberFormatType`
    /// function.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub number_format: Option<String>,
    /// [Custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type) for
    /// `config.numberFormat`.
    ///
    /// __Default value:__ `undefined` -- This is equilvalent to call D3-format, which is exposed
    /// as [`format` in Vega-Expression](https://vega.github.io/vega/docs/expressions/#format).
    /// __Note:__ You must also set `customFormatTypes` to `true` to use this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub number_format_type: Option<String>,
    /// Default time format for raw time values (without time units) in text marks, legend labels
    /// and header labels.
    ///
    /// __Default value:__ `"%b %d, %Y"` __Note:__ Axes automatically determine the format for
    /// each label automatically so this config does not affect axes.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_format: Option<String>,
    /// [Custom format
    /// type](https://vega.github.io/vega-lite/docs/config.html#custom-format-type) for
    /// `config.timeFormat`.
    ///
    /// __Default value:__ `undefined` -- This is equilvalent to call D3-time-format, which is
    /// exposed as [`timeFormat` in
    /// Vega-Expression](https://vega.github.io/vega/docs/expressions/#timeFormat). __Note:__ You
    /// must also set `customFormatTypes` to `true` and there must *not* be a `timeUnit` defined
    /// to use this feature.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub time_format_type: Option<String>,
}

/// Default properties for [single view
/// plots](https://vega.github.io/vega-lite/docs/spec.html#single).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct ViewConfig {
    /// Whether the view should be clipped.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub clip: Option<bool>,
    /// The default height when the plot has a continuous y-field for x or latitude, or has arc
    /// marks.
    ///
    /// __Default value:__ `200`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_height: Option<f64>,
    /// The default width when the plot has a continuous field for x or longitude, or has arc
    /// marks.
    ///
    /// __Default value:__ `200`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub continuous_width: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub corner_radius: Option<CornerRadiusUnion>,
    /// The mouse cursor used over the view. Any valid [CSS cursor
    /// type](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#Values) can be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub cursor: Option<Cursor>,
    /// The default height when the plot has non arc marks and either a discrete y-field or no
    /// y-field. The height can be either a number indicating a fixed height or an object in the
    /// form of `{step: number}` defining the height per discrete step.
    ///
    /// __Default value:__ a step size based on `config.view.step`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_height: Option<DiscreteHeightUnion>,
    /// The default width when the plot has non-arc marks and either a discrete x-field or no
    /// x-field. The width can be either a number indicating a fixed width or an object in the
    /// form of `{step: number}` defining the width per discrete step.
    ///
    /// __Default value:__ a step size based on `config.view.step`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub discrete_width: Option<DiscreteWidthUnion>,
    /// The fill color.
    ///
    /// __Default value:__ `undefined`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill: Option<Box<Color>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub fill_opacity: Option<Opacity>,
    /// The overall opacity (value between [0,1]).
    ///
    /// __Default value:__ `0.7` for non-aggregate plots with `point`, `tick`, `circle`, or
    /// `square` marks or layered `bar` charts and `1` otherwise.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub opacity: Option<CornerRadiusUnion>,
    /// Default step size for x-/y- discrete fields.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
    /// The stroke color.
    ///
    /// __Default value:__ `"#ddd"`
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub stroke: RemovableValue<Color>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_cap: Option<Cap>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash: Option<StrokeDashUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_dash_offset: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_join: Option<StrokeJoinUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_miter_limit: Option<CornerRadiusUnion>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_opacity: Option<Opacity>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub stroke_width: Option<FontSize>,
}

/// The default height when the plot has non arc marks and either a discrete y-field or no
/// y-field. The height can be either a number indicating a fixed height or an object in the
/// form of `{step: number}` defining the height per discrete step.
///
/// __Default value:__ a step size based on `config.view.step`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DiscreteHeightUnion {
    DiscreteHeightClass(DiscreteHeightClass),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DiscreteHeightClass {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
}

/// The default width when the plot has non-arc marks and either a discrete x-field or no
/// x-field. The width can be either a number indicating a fixed width or an object in the
/// form of `{step: number}` defining the width per discrete step.
///
/// __Default value:__ a step size based on `config.view.step`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum DiscreteWidthUnion {
    DiscreteWidthClass(DiscreteWidthClass),
    Double(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct DiscreteWidthClass {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub step: Option<f64>,
}

/// The full data set, included inline. This can be an array of objects or primitive values,
/// an object, or a string. Arrays of primitive values are ingested as objects with a `data`
/// property. Strings are parsed according to the specified format type.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
#[derive(From)]
pub enum InlineDatasetValue {
    AnythingMap(HashMap<String, Option<serde_json::Value>>),
    String(String),
    UnionArray(Vec<serde_json::value::Value>),
}

/// A specification of the view that gets faceted.
///
/// A specification of the view that gets repeated.
///
/// A full layered plot specification, which may contains `encoding` and `projection`
/// properties that will be applied to underlying unit (single-view) specifications.
///
/// Any specification in Vega-Lite.
///
/// Unit spec that can have a composite mark and row or column channels (shorthand for a
/// facet spec).
///
/// Base interface for a repeat specification.
///
/// Base interface for a facet specification.
///
/// Base interface for a generalized concatenation specification.
///
/// Base interface for a vertical concatenation specification.
///
/// Base interface for a horizontal concatenation specification.
#[derive(Debug, Clone, Serialize, Deserialize, Default, Builder)]
#[builder(setter(into, strip_option))]
pub struct VegaliteSpec {
    /// An object describing the data source. Set to `null` to ignore the parent's data source.
    /// If no data is set, it is derived from the parent.
    #[serde(default, skip_serializing_if = "RemovableValue::is_default")]
    #[builder(default)]
    pub data: RemovableValue<UrlData>,
    /// Description of this mark for commenting purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub description: Option<String>,
    /// A shared key-value mapping between encoding channels and definition of fields in the
    /// underlying layers.
    ///
    /// A key-value mapping between encoding channels and definition of fields.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub encoding: Option<SpecEncoding>,
    /// The height of a visualization.
    ///
    /// - For a plot with a continuous y-field, height should be a number.
    /// - For a plot with either a discrete y-field or no y-field, height can be either a number
    /// indicating a fixed height or an object in the form of `{step: number}` defining the
    /// height per discrete step. (No y-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on height, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousHeight` for a plot with a continuous
    /// y-field and `config.view.discreteHeight` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// height of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`height`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub height: Option<SpecHeight>,
    /// Layer or single view specifications to be layered.
    ///
    /// __Note__: Specifications inside `layer` cannot use `row` and `column` channels as
    /// layering facet specifications is not allowed. Instead, use the [facet
    /// operator](https://vega.github.io/vega-lite/docs/facet.html) and place a layer inside a
    /// facet.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub layer: Option<Vec<LayerSpec>>,
    /// Name of the visualization for later reference.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub name: Option<String>,
    /// An object defining properties of the geographic projection shared by underlying layers.
    ///
    /// An object defining properties of geographic projection, which will be applied to `shape`
    /// path for `"geoshape"` marks and to `latitude` and `"longitude"` channels for other marks.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub projection: Option<Box<Projection>>,
    /// Scale, axis, and legend resolutions for view composition specifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub resolve: Option<Box<Resolve>>,
    /// Title for the plot.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub title: Option<TitleUnion>,
    /// An array of data transformations such as filter and new field calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub transform: Option<Vec<Transform>>,
    /// An object defining the view background's fill and stroke.
    ///
    /// __Default value:__ none (transparent)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub view: Option<Box<ViewBackground>>,
    /// The width of a visualization.
    ///
    /// - For a plot with a continuous x-field, width should be a number.
    /// - For a plot with either a discrete x-field or no x-field, width can be either a number
    /// indicating a fixed width or an object in the form of `{step: number}` defining the width
    /// per discrete step. (No x-field is equivalent to having one discrete step.)
    /// - To enable responsive sizing on width, it should be set to `"container"`.
    ///
    /// __Default value:__ Based on `config.view.continuousWidth` for a plot with a continuous
    /// x-field and `config.view.discreteWidth` otherwise.
    ///
    /// __Note:__ For plots with [`row` and `column`
    /// channels](https://vega.github.io/vega-lite/docs/encoding.html#facet), this represents the
    /// width of a single view and the `"container"` option cannot be used.
    ///
    /// __See also:__ [`width`](https://vega.github.io/vega-lite/docs/size.html) documentation.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub width: Option<SpecHeight>,
    /// A string describing the mark type (one of `"bar"`, `"circle"`, `"square"`, `"tick"`,
    /// `"line"`, `"area"`, `"point"`, `"rule"`, `"geoshape"`, and `"text"`) or a [mark
    /// definition object](https://vega.github.io/vega-lite/docs/mark.html#mark-def).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub mark: Option<AnyMark>,
    /// An array of parameters that may either be simple variables, or more complex selections
    /// that map user input to data queries.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub params: Option<Vec<SelectionParameter>>,
    /// The alignment to apply to grid rows and columns. The supported string values are `"all"`,
    /// `"each"`, and `"none"`.
    ///
    /// - For `"none"`, a flow layout will be used, in which adjacent subviews are simply placed
    /// one after the other.
    /// - For `"each"`, subviews will be aligned into a clean grid structure, but each row or
    /// column may be of variable size.
    /// - For `"all"`, subviews will be aligned and each row or column will be sized identically
    /// based on the maximum observed size. String values for this property will be applied to
    /// both grid rows and columns.
    ///
    /// Alternatively, an object value of the form `{"row": string, "column": string}` can be
    /// used to supply different alignments for rows and columns.
    ///
    /// __Default value:__ `"all"`.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub align: Option<Box<VegaliteAlign>>,
    /// The bounds calculation method to use for determining the extent of a sub-plot. One of
    /// `full` (the default) or `flush`.
    ///
    /// - If set to `full`, the entire calculated bounds (including axes, title, and legend) will
    /// be used.
    /// - If set to `flush`, only the specified width and height values for the sub-view will be
    /// used. The `flush` setting can be useful when attempting to place sub-plots without axes
    /// or legends into a uniform grid structure.
    ///
    /// __Default value:__ `"full"`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub bounds: Option<Box<Bounds>>,
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// An object value of the form `{"row": boolean, "column": boolean}` can be used to supply
    /// different centering values for rows and columns.
    ///
    /// __Default value:__ `false`
    ///
    /// Boolean flag indicating if subviews should be centered relative to their respective rows
    /// or columns.
    ///
    /// __Default value:__ `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub center: Option<Box<Center>>,
    /// The spacing in pixels between sub-views of the composition operator. An object of the
    /// form `{"row": number, "column": number}` can be used to set different spacing values for
    /// rows and columns.
    ///
    /// __Default value__: Depends on `"spacing"` property of [the view composition
    /// configuration](https://vega.github.io/vega-lite/docs/config.html#view-config) (`20` by
    /// default)
    ///
    /// The spacing in pixels between sub-views of the concat operator.
    ///
    /// __Default value__: `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spacing: Option<Box<Spacing>>,
    /// The number of columns to include in the view composition layout.
    ///
    /// __Default value__: `undefined` -- An infinite number of columns (a single row) will be
    /// assumed. This is equivalent to `hconcat` (for `concat`) and to using the `column` channel
    /// (for `facet` and `repeat`).
    ///
    /// __Note__:
    ///
    /// 1) This property is only for:
    /// - the general (wrappable) `concat` operator (not `hconcat`/`vconcat`)
    /// - the `facet` and `repeat` operator with one field/repetition definition (without
    /// row/column nesting)
    ///
    /// 2) Setting the `columns` to `1` is equivalent to `vconcat` (for `concat`) and to using
    /// the `row` channel (for `facet` and `repeat`).
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub columns: Option<f64>,
    /// Definition for fields to be repeated. One of: 1) An array of fields to be repeated. If
    /// `"repeat"` is an array, the field can be referred to as `{"repeat": "repeat"}`. The
    /// repeated views are laid out in a wrapped row. You can set the number of columns to
    /// control the wrapping. 2) An object that maps `"row"` and/or `"column"` to the listed
    /// fields to be repeated along the particular orientations. The objects `{"repeat": "row"}`
    /// and `{"repeat": "column"}` can be used to refer to the repeated field respectively.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub repeat: Option<Box<RepeatUnion>>,
    /// A specification of the view that gets repeated.
    ///
    /// A specification of the view that gets faceted.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub spec: Option<Box<SpecSpec>>,
    /// Definition for how to facet the data. One of: 1) [a field definition for faceting the
    /// plot by one field](https://vega.github.io/vega-lite/docs/facet.html#field-def) 2) [An
    /// object that maps `row` and `column` channels to their field
    /// definitions](https://vega.github.io/vega-lite/docs/facet.html#mapping)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub facet: Option<Box<Facet>>,
    /// A list of views to be concatenated.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub concat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a column.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub vconcat: Option<Vec<Spec>>,
    /// A list of views to be concatenated and put into a row.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(default)]
    pub hconcat: Option<Vec<Spec>>,
}