diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e312d3662..c06b71e71 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -64,7 +64,7 @@ jobs:
           fi
       - name: Test with pytest
         run: |
-          pytest --doctest-modules tests
+          pytest --pyargs --numprocesses=logical --doctest-modules tests
       - name: Validate Vega-Lite schema
         run: |
           # We install all 'format' dependencies of jsonschema as check-jsonschema
diff --git a/.github/workflows/docbuild.yml b/.github/workflows/docbuild.yml
index 351ea5c45..585630bea 100644
--- a/.github/workflows/docbuild.yml
+++ b/.github/workflows/docbuild.yml
@@ -7,10 +7,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - name: Set up Python 3.10
+    - name: Set up Python 3.12
       uses: actions/setup-python@v5
       with:
-        python-version: "3.10"
+        python-version: "3.12"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 045bac9e8..4e89e2777 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -8,22 +8,22 @@ jobs:
     name: ruff-mypy
     steps:
     - uses: actions/checkout@v4
-    - name: Set up Python 3.10
+    - name: Set up Python 3.12
       uses: actions/setup-python@v5
       with:
-        python-version: "3.10"
+        python-version: "3.12"
     # Installing all dependencies and not just the linters as mypy needs them for type checking
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install ".[all, dev]"
+        pip install hatch
     - name: Lint with ruff
       run: |        
-        ruff check .        
+        hatch run ruff check .        
     - name: Check formatting with ruff
       run: |
-        ruff format --diff .
-        ruff format --check .
+        hatch run ruff format --diff .
+        hatch run ruff format --check .
     - name: Lint with mypy
       run: |
-        mypy altair tests
+        hatch run mypy altair tests
diff --git a/altair/__init__.py b/altair/__init__.py
index 2f9e4acad..bd81f0209 100644
--- a/altair/__init__.py
+++ b/altair/__init__.py
@@ -128,7 +128,6 @@
     "Cyclical",
     "Data",
     "DataFormat",
-    "DataFrameLike",
     "DataSource",
     "DataType",
     "Datasets",
@@ -307,6 +306,7 @@
     "Opacity",
     "OpacityDatum",
     "OpacityValue",
+    "Optional",
     "Order",
     "OrderFieldDef",
     "OrderOnlyDef",
@@ -494,7 +494,6 @@
     "TypedFieldDef",
     "URI",
     "Undefined",
-    "UndefinedType",
     "UnitSpec",
     "UnitSpecWithFrame",
     "Url",
diff --git a/altair/_magics.py b/altair/_magics.py
index 246ea2a1f..28e6d832f 100644
--- a/altair/_magics.py
+++ b/altair/_magics.py
@@ -46,7 +46,7 @@ def _prepare_data(data, data_transformers):
     elif isinstance(data, str):
         return {"url": data}
     else:
-        warnings.warn("data of type {} not recognized".format(type(data)), stacklevel=1)
+        warnings.warn(f"data of type {type(data)} not recognized", stacklevel=1)
         return data
 
 
@@ -54,14 +54,14 @@ def _get_variable(name):
     """Get a variable from the notebook namespace."""
     ip = IPython.get_ipython()
     if ip is None:
-        raise ValueError(
+        msg = (
             "Magic command must be run within an IPython "
             "environment, in which get_ipython() is defined."
         )
+        raise ValueError(msg)
     if name not in ip.user_ns:
-        raise NameError(
-            "argument '{}' does not match the name of any defined variable".format(name)
-        )
+        msg = f"argument '{name}' does not match the name of any defined variable"
+        raise NameError(msg)
     return ip.user_ns[name]
 
 
@@ -96,10 +96,11 @@ def vegalite(line, cell):
         try:
             spec = json.loads(cell)
         except json.JSONDecodeError as err:
-            raise ValueError(
+            msg = (
                 "%%vegalite: spec is not valid JSON. "
                 "Install pyyaml to parse spec as yaml"
-            ) from err
+            )
+            raise ValueError(msg) from err
     else:
         spec = yaml.load(cell, Loader=yaml.SafeLoader)
 
diff --git a/altair/expr/consts.py b/altair/expr/consts.py
index 974fb06a3..4e778c069 100644
--- a/altair/expr/consts.py
+++ b/altair/expr/consts.py
@@ -1,4 +1,4 @@
-from typing import Dict
+from __future__ import annotations
 
 from .core import ConstExpression
 
@@ -15,7 +15,7 @@
     "PI": "the transcendental number pi (alias to Math.PI)",
 }
 
-NAME_MAP: Dict[str, str] = {}
+NAME_MAP: dict[str, str] = {}
 
 
 def _populate_namespace():
diff --git a/altair/expr/core.py b/altair/expr/core.py
index 9cc258c8b..986501178 100644
--- a/altair/expr/core.py
+++ b/altair/expr/core.py
@@ -1,21 +1,23 @@
+from __future__ import annotations
+from typing import Any
 from ..utils import SchemaBase
 
 
 class DatumType:
     """An object to assist in building Vega-Lite Expressions"""
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "datum"
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr) -> GetAttrExpression:
         if attr.startswith("__") and attr.endswith("__"):
             raise AttributeError(attr)
         return GetAttrExpression("datum", attr)
 
-    def __getitem__(self, attr):
+    def __getitem__(self, attr) -> GetItemExpression:
         return GetItemExpression("datum", attr)
 
-    def __call__(self, datum, **kwargs):
+    def __call__(self, datum, **kwargs) -> dict[str, Any]:
         """Specify a datum for use in an encoding"""
         return dict(datum=datum, **kwargs)
 
@@ -23,7 +25,7 @@ def __call__(self, datum, **kwargs):
 datum = DatumType()
 
 
-def _js_repr(val):
+def _js_repr(val) -> str:
     """Return a javascript-safe string representation of val"""
     if val is True:
         return "true"
@@ -39,10 +41,10 @@ def _js_repr(val):
 
 # Designed to work with Expression and VariableParameter
 class OperatorMixin:
-    def _to_expr(self):
+    def _to_expr(self) -> str:
         return repr(self)
 
-    def _from_expr(self, expr):
+    def _from_expr(self, expr) -> Any:
         return expr
 
     def __add__(self, other):
@@ -173,7 +175,7 @@ class Expression(OperatorMixin, SchemaBase):
     def to_dict(self, *args, **kwargs):
         return repr(self)
 
-    def __setattr__(self, attr, val):
+    def __setattr__(self, attr, val) -> None:
         # We don't need the setattr magic defined in SchemaBase
         return object.__setattr__(self, attr, val)
 
@@ -183,52 +185,50 @@ def __getitem__(self, val):
 
 
 class UnaryExpression(Expression):
-    def __init__(self, op, val):
-        super(UnaryExpression, self).__init__(op=op, val=val)
+    def __init__(self, op, val) -> None:
+        super().__init__(op=op, val=val)
 
     def __repr__(self):
-        return "({op}{val})".format(op=self.op, val=_js_repr(self.val))
+        return f"({self.op}{_js_repr(self.val)})"
 
 
 class BinaryExpression(Expression):
-    def __init__(self, op, lhs, rhs):
-        super(BinaryExpression, self).__init__(op=op, lhs=lhs, rhs=rhs)
+    def __init__(self, op, lhs, rhs) -> None:
+        super().__init__(op=op, lhs=lhs, rhs=rhs)
 
     def __repr__(self):
-        return "({lhs} {op} {rhs})".format(
-            op=self.op, lhs=_js_repr(self.lhs), rhs=_js_repr(self.rhs)
-        )
+        return f"({_js_repr(self.lhs)} {self.op} {_js_repr(self.rhs)})"
 
 
 class FunctionExpression(Expression):
-    def __init__(self, name, args):
-        super(FunctionExpression, self).__init__(name=name, args=args)
+    def __init__(self, name, args) -> None:
+        super().__init__(name=name, args=args)
 
     def __repr__(self):
         args = ",".join(_js_repr(arg) for arg in self.args)
-        return "{name}({args})".format(name=self.name, args=args)
+        return f"{self.name}({args})"
 
 
 class ConstExpression(Expression):
-    def __init__(self, name, doc):
-        self.__doc__ = """{}: {}""".format(name, doc)
-        super(ConstExpression, self).__init__(name=name, doc=doc)
+    def __init__(self, name, doc) -> None:
+        self.__doc__ = f"""{name}: {doc}"""
+        super().__init__(name=name, doc=doc)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(self.name)
 
 
 class GetAttrExpression(Expression):
-    def __init__(self, group, name):
-        super(GetAttrExpression, self).__init__(group=group, name=name)
+    def __init__(self, group, name) -> None:
+        super().__init__(group=group, name=name)
 
     def __repr__(self):
-        return "{}.{}".format(self.group, self.name)
+        return f"{self.group}.{self.name}"
 
 
 class GetItemExpression(Expression):
-    def __init__(self, group, name):
-        super(GetItemExpression, self).__init__(group=group, name=name)
+    def __init__(self, group, name) -> None:
+        super().__init__(group=group, name=name)
 
-    def __repr__(self):
-        return "{}[{!r}]".format(self.group, self.name)
+    def __repr__(self) -> str:
+        return f"{self.group}[{self.name!r}]"
diff --git a/altair/expr/funcs.py b/altair/expr/funcs.py
index c4a73f4c9..e252a1b36 100644
--- a/altair/expr/funcs.py
+++ b/altair/expr/funcs.py
@@ -1,5 +1,10 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
 from .core import FunctionExpression
 
+if TYPE_CHECKING:
+    from typing import Iterator
+
 
 FUNCTION_LISTING = {
     "isArray": r"Returns true if _value_ is an array, false otherwise.",
@@ -169,19 +174,19 @@
 
 
 class ExprFunc:
-    def __init__(self, name, doc):
+    def __init__(self, name, doc) -> None:
         self.name = name
         self.doc = doc
-        self.__doc__ = """{}(*args)\n    {}""".format(name, doc)
+        self.__doc__ = f"""{name}(*args)\n    {doc}"""
 
-    def __call__(self, *args):
+    def __call__(self, *args) -> FunctionExpression:
         return FunctionExpression(self.name, args)
 
-    def __repr__(self):
-        return "<function expr.{}(*args)>".format(self.name)
+    def __repr__(self) -> str:
+        return f"<function expr.{self.name}(*args)>"
 
 
-def _populate_namespace():
+def _populate_namespace() -> Iterator[str]:
     globals_ = globals()
     for name, doc in FUNCTION_LISTING.items():
         py_name = NAME_MAP.get(name, name)
diff --git a/altair/jupyter/__init__.py b/altair/jupyter/__init__.py
index 651ab11e4..c57815a2f 100644
--- a/altair/jupyter/__init__.py
+++ b/altair/jupyter/__init__.py
@@ -7,7 +7,7 @@
     # when anywidget is not installed
     class JupyterChart:
         def __init__(self, *args, **kwargs):
-            raise ImportError(
+            msg = (
                 "The Altair JupyterChart requires the anywidget \n"
                 "Python package which may be installed using pip with\n"
                 "    pip install anywidget\n"
@@ -15,6 +15,7 @@ def __init__(self, *args, **kwargs):
                 "    conda install -c conda-forge anywidget\n"
                 "Afterwards, you will need to restart your Python kernel."
             )
+            raise ImportError(msg)
 
 else:
     from .jupyter_chart import JupyterChart  # noqa: F401
diff --git a/altair/jupyter/jupyter_chart.py b/altair/jupyter/jupyter_chart.py
index 0331c9820..0d0a94885 100644
--- a/altair/jupyter/jupyter_chart.py
+++ b/altair/jupyter/jupyter_chart.py
@@ -1,8 +1,9 @@
+from __future__ import annotations
 import json
 import anywidget
 import traitlets
 import pathlib
-from typing import Any, Set, Optional
+from typing import Any
 
 import altair as alt
 from altair.utils._vegafusion_data import (
@@ -61,7 +62,8 @@ def __init__(self, trait_values):
             elif isinstance(value, IntervalSelection):
                 traitlet_type = traitlets.Instance(IntervalSelection)
             else:
-                raise ValueError(f"Unexpected selection type: {type(value)}")
+                msg = f"Unexpected selection type: {type(value)}"
+                raise ValueError(msg)
 
             # Add the new trait.
             self.add_traits(**{key: traitlet_type})
@@ -82,10 +84,11 @@ def _make_read_only(self, change):
         """
         if change["name"] in self.traits() and change["old"] != change["new"]:
             self._set_value(change["name"], change["old"])
-        raise ValueError(
+        msg = (
             "Selections may not be set from Python.\n"
             f"Attempted to set select: {change['name']}"
         )
+        raise ValueError(msg)
 
     def _set_value(self, key, value):
         self.unobserve(self._make_read_only, names=key)
@@ -185,7 +188,7 @@ def __init__(
         debounce_wait: int = 10,
         max_wait: bool = True,
         debug: bool = False,
-        embed_options: Optional[dict] = None,
+        embed_options: dict | None = None,
         **kwargs: Any,
     ):
         """
@@ -278,7 +281,8 @@ def _on_change_chart(self, change):
                             name=clean_name, value={}, store=[]
                         )
                     else:
-                        raise ValueError(f"Unexpected selection type {select.type}")
+                        msg = f"Unexpected selection type {select.type}"
+                        raise ValueError(msg)
                     selection_watches.append(clean_name)
                     initial_vl_selections[clean_name] = {"value": None, "store": []}
                 else:
@@ -384,7 +388,7 @@ def _on_change_selections(self, change):
                 )
 
 
-def collect_transform_params(chart: TopLevelSpec) -> Set[str]:
+def collect_transform_params(chart: TopLevelSpec) -> set[str]:
     """
     Collect the names of params that are defined by transforms
 
diff --git a/altair/utils/__init__.py b/altair/utils/__init__.py
index dba1e1f81..64d6f4566 100644
--- a/altair/utils/__init__.py
+++ b/altair/utils/__init__.py
@@ -12,21 +12,22 @@
 from .html import spec_to_html
 from .plugin_registry import PluginRegistry
 from .deprecation import AltairDeprecationWarning
-from .schemapi import Undefined
+from .schemapi import Undefined, Optional
 
 
 __all__ = (
-    "infer_vegalite_type",
+    "AltairDeprecationWarning",
+    "Optional",
+    "PluginRegistry",
+    "SchemaBase",
+    "Undefined",
+    "display_traceback",
     "infer_encoding_types",
-    "sanitize_dataframe",
+    "infer_vegalite_type",
+    "parse_shorthand",
     "sanitize_arrow_table",
+    "sanitize_dataframe",
     "spec_to_html",
-    "parse_shorthand",
-    "use_signature",
     "update_nested",
-    "display_traceback",
-    "AltairDeprecationWarning",
-    "SchemaBase",
-    "Undefined",
-    "PluginRegistry",
+    "use_signature",
 )
diff --git a/altair/utils/_dfi_types.py b/altair/utils/_dfi_types.py
index a76435e7f..0d6f38b04 100644
--- a/altair/utils/_dfi_types.py
+++ b/altair/utils/_dfi_types.py
@@ -4,8 +4,9 @@
 # relevant for Altair.
 #
 # These classes are only for use in type signatures
+from __future__ import annotations
 import enum
-from typing import Any, Iterable, Optional, Tuple, Protocol
+from typing import Any, Iterable, Protocol
 
 
 class DtypeKind(enum.IntEnum):
@@ -43,12 +44,9 @@ class DtypeKind(enum.IntEnum):
 # as other libraries won't use an instance of our own Enum in this module but have
 # their own. Type checkers will raise an error on that even though the enums
 # are identical.
-Dtype = Tuple[Any, int, str, str]  # see Column.dtype
-
-
 class Column(Protocol):
     @property
-    def dtype(self) -> Dtype:
+    def dtype(self) -> tuple[Any, int, str, str]:
         """
         Dtype description as a tuple ``(kind, bit-width, format string, endianness)``.
 
@@ -76,7 +74,6 @@ def dtype(self) -> Dtype:
             - Data types not included: complex, Arrow-style null, binary, decimal,
               and nested (list, struct, map, union) dtypes.
         """
-        pass
 
     # Have to use a generic Any return type as not all libraries who implement
     # the dataframe interchange protocol implement the TypedDict that is usually
@@ -103,7 +100,6 @@ def describe_categorical(self) -> Any:
 
         TBD: are there any other in-memory representations that are needed?
         """
-        pass
 
 
 class DataFrame(Protocol):
@@ -123,7 +119,7 @@ class DataFrame(Protocol):
 
     def __dataframe__(
         self, nan_as_null: bool = False, allow_copy: bool = True
-    ) -> "DataFrame":
+    ) -> DataFrame:
         """
         Construct a new exchange object, potentially changing the parameters.
 
@@ -136,21 +132,18 @@ def __dataframe__(
         necessary if a library supports strided buffers, given that this protocol
         specifies contiguous buffers.
         """
-        pass
 
     def column_names(self) -> Iterable[str]:
         """
         Return an iterator yielding the column names.
         """
-        pass
 
     def get_column_by_name(self, name: str) -> Column:
         """
         Return the column whose name is the indicated name.
         """
-        pass
 
-    def get_chunks(self, n_chunks: Optional[int] = None) -> Iterable["DataFrame"]:
+    def get_chunks(self, n_chunks: int | None = None) -> Iterable[DataFrame]:
         """
         Return an iterator yielding the chunks.
 
@@ -162,4 +155,3 @@ def get_chunks(self, n_chunks: Optional[int] = None) -> Iterable["DataFrame"]:
         Note that the producer must ensure that all columns are chunked the
         same way.
         """
-        pass
diff --git a/altair/utils/_importers.py b/altair/utils/_importers.py
index 9f7f567e4..118cc6e10 100644
--- a/altair/utils/_importers.py
+++ b/altair/utils/_importers.py
@@ -1,8 +1,13 @@
+from __future__ import annotations
+
 from importlib.metadata import version as importlib_version
-from types import ModuleType
+from typing import TYPE_CHECKING
 
 from packaging.version import Version
 
+if TYPE_CHECKING:
+    from types import ModuleType
+
 
 def import_vegafusion() -> ModuleType:
     min_version = "1.5.0"
@@ -10,18 +15,19 @@ def import_vegafusion() -> ModuleType:
         version = importlib_version("vegafusion")
         embed_version = importlib_version("vegafusion-python-embed")
         if version != embed_version or Version(version) < Version(min_version):
-            raise RuntimeError(
+            msg = (
                 "The versions of the vegafusion and vegafusion-python-embed packages must match\n"
                 f"and must be version {min_version} or greater.\n"
                 f"Found:\n"
                 f" - vegafusion=={version}\n"
                 f" - vegafusion-python-embed=={embed_version}\n"
             )
+            raise RuntimeError(msg)
         import vegafusion as vf  # type: ignore
 
         return vf
     except ImportError as err:
-        raise ImportError(
+        msg = (
             'The "vegafusion" data transformer and chart.transformed_data feature requires\n'
             f"version {min_version} or greater of the 'vegafusion-python-embed' and 'vegafusion' packages.\n"
             "These can be installed with pip using:\n"
@@ -30,7 +36,8 @@ def import_vegafusion() -> ModuleType:
             f'    conda install -c conda-forge "vegafusion-python-embed>={min_version}" '
             f'"vegafusion>={min_version}"\n\n'
             f"ImportError: {err.args[0]}"
-        ) from err
+        )
+        raise ImportError(msg) from err
 
 
 def import_vl_convert() -> ModuleType:
@@ -38,15 +45,16 @@ def import_vl_convert() -> ModuleType:
     try:
         version = importlib_version("vl-convert-python")
         if Version(version) < Version(min_version):
-            raise RuntimeError(
+            msg = (
                 f"The vl-convert-python package must be version {min_version} or greater. "
                 f"Found version {version}"
             )
+            raise RuntimeError(msg)
         import vl_convert as vlc
 
         return vlc
     except ImportError as err:
-        raise ImportError(
+        msg = (
             f"The vl-convert Vega-Lite compiler and file export feature requires\n"
             f"version {min_version} or greater of the 'vl-convert-python' package. \n"
             f"This can be installed with pip using:\n"
@@ -54,7 +62,8 @@ def import_vl_convert() -> ModuleType:
             "or conda:\n"
             f'   conda install -c conda-forge "vl-convert-python>={min_version}"\n\n'
             f"ImportError: {err.args[0]}"
-        ) from err
+        )
+        raise ImportError(msg) from err
 
 
 def vl_version_for_vl_convert() -> str:
@@ -71,15 +80,16 @@ def import_pyarrow_interchange() -> ModuleType:
         version = importlib_version("pyarrow")
 
         if Version(version) < Version(min_version):
-            raise RuntimeError(
+            msg = (
                 f"The pyarrow package must be version {min_version} or greater. "
                 f"Found version {version}"
             )
+            raise RuntimeError(msg)
         import pyarrow.interchange as pi
 
         return pi
     except ImportError as err:
-        raise ImportError(
+        msg = (
             f"Usage of the DataFrame Interchange Protocol requires\n"
             f"version {min_version} or greater of the pyarrow package. \n"
             f"This can be installed with pip using:\n"
@@ -87,7 +97,8 @@ def import_pyarrow_interchange() -> ModuleType:
             "or conda:\n"
             f'   conda install -c conda-forge "pyarrow>={min_version}"\n\n'
             f"ImportError: {err.args[0]}"
-        ) from err
+        )
+        raise ImportError(msg) from err
 
 
 def pyarrow_available() -> bool:
diff --git a/altair/utils/_show.py b/altair/utils/_show.py
index 0030570ac..325b9e91a 100644
--- a/altair/utils/_show.py
+++ b/altair/utils/_show.py
@@ -1,13 +1,14 @@
+from __future__ import annotations
 import webbrowser
 from http.server import BaseHTTPRequestHandler, HTTPServer
-from typing import Union, Iterable, Optional
+from typing import Iterable
 
 
 def open_html_in_browser(
-    html: Union[str, bytes],
-    using: Union[str, Iterable[str], None] = None,
-    port: Optional[int] = None,
-):
+    html: str | bytes,
+    using: str | Iterable[str] | None = None,
+    port: int | None = None,
+) -> None:
     """
     Display an html document in a web browser without creating a temp file.
 
@@ -26,10 +27,7 @@ def open_html_in_browser(
         Port to use. Defaults to a random port
     """
     # Encode html to bytes
-    if isinstance(html, str):
-        html_bytes = html.encode("utf8")
-    else:
-        html_bytes = html
+    html_bytes = html.encode("utf8") if isinstance(html, str) else html
 
     browser = None
 
@@ -52,7 +50,7 @@ def open_html_in_browser(
             raise ValueError("Failed to locate a browser with name in " + str(using))
 
     class OneShotRequestHandler(BaseHTTPRequestHandler):
-        def do_GET(self):
+        def do_GET(self) -> None:
             self.send_response(200)
             self.send_header("Content-type", "text/html")
             self.end_headers()
@@ -69,5 +67,5 @@ def log_message(self, format, *args):
     server = HTTPServer(
         ("127.0.0.1", port if port is not None else 0), OneShotRequestHandler
     )
-    browser.open("http://127.0.0.1:%s" % server.server_port)
+    browser.open(f"http://127.0.0.1:{server.server_port}")
     server.handle_request()
diff --git a/altair/utils/_transformed_data.py b/altair/utils/_transformed_data.py
index 7a616b9c5..798b60d63 100644
--- a/altair/utils/_transformed_data.py
+++ b/altair/utils/_transformed_data.py
@@ -1,5 +1,6 @@
-from typing import List, Optional, Tuple, Dict, Iterable, overload, Union
-
+from __future__ import annotations
+from typing import Any, Iterable, overload, TYPE_CHECKING, Dict, Tuple
+from typing_extensions import TypeAlias
 from altair import (
     Chart,
     FacetChart,
@@ -25,11 +26,13 @@
     data_transformers,
 )
 from altair.utils._vegafusion_data import get_inline_tables, import_vegafusion
-from altair.utils.core import DataFrameLike
 from altair.utils.schemapi import Undefined
 
-Scope = Tuple[int, ...]
-FacetMapping = Dict[Tuple[str, Scope], Tuple[str, Scope]]
+if TYPE_CHECKING:
+    from altair.utils.core import DataFrameLike
+
+Scope: TypeAlias = Tuple[int, ...]
+FacetMapping: TypeAlias = Dict[Tuple[str, Scope], Tuple[str, Scope]]
 
 
 # For the transformed_data functionality, the chart classes in the values
@@ -53,18 +56,18 @@
 
 @overload
 def transformed_data(
-    chart: Union[Chart, FacetChart],
-    row_limit: Optional[int] = None,
-    exclude: Optional[Iterable[str]] = None,
-) -> Optional[DataFrameLike]: ...
+    chart: Chart | FacetChart,
+    row_limit: int | None = None,
+    exclude: Iterable[str] | None = None,
+) -> DataFrameLike | None: ...
 
 
 @overload
 def transformed_data(
-    chart: Union[LayerChart, HConcatChart, VConcatChart, ConcatChart],
-    row_limit: Optional[int] = None,
-    exclude: Optional[Iterable[str]] = None,
-) -> List[DataFrameLike]: ...
+    chart: LayerChart | HConcatChart | VConcatChart | ConcatChart,
+    row_limit: int | None = None,
+    exclude: Iterable[str] | None = None,
+) -> list[DataFrameLike]: ...
 
 
 def transformed_data(chart, row_limit=None, exclude=None):
@@ -90,11 +93,9 @@ def transformed_data(chart, row_limit=None, exclude=None):
         transformed data
     """
     vf = import_vegafusion()
-
-    if isinstance(chart, Chart):
-        # Add mark if none is specified to satisfy Vega-Lite
-        if chart.mark == Undefined:
-            chart = chart.mark_point()
+    # Add mark if none is specified to satisfy Vega-Lite
+    if isinstance(chart, Chart) and chart.mark == Undefined:
+        chart = chart.mark_point()
 
     # Deep copy chart so that we can rename marks without affecting caller
     chart = chart.copy(deep=True)
@@ -119,10 +120,11 @@ def transformed_data(chart, row_limit=None, exclude=None):
         if chart_name in dataset_mapping:
             dataset_names.append(dataset_mapping[chart_name])
         else:
-            raise ValueError("Failed to locate all datasets")
+            msg = "Failed to locate all datasets"
+            raise ValueError(msg)
 
     # Extract transformed datasets with VegaFusion
-    datasets, warnings = vf.runtime.pre_transform_datasets(
+    datasets, _ = vf.runtime.pre_transform_datasets(
         vega_spec,
         dataset_names,
         row_limit=row_limit,
@@ -151,12 +153,10 @@ def transformed_data(chart, row_limit=None, exclude=None):
 # The same error appeared when trying it with Protocols for the concat and layer charts.
 # This function is only used internally and so we accept this inconsistency for now.
 def name_views(
-    chart: Union[
-        Chart, FacetChart, LayerChart, HConcatChart, VConcatChart, ConcatChart
-    ],
+    chart: Chart | FacetChart | LayerChart | HConcatChart | VConcatChart | ConcatChart,
     i: int = 0,
-    exclude: Optional[Iterable[str]] = None,
-) -> List[str]:
+    exclude: Iterable[str] | None = None,
+) -> list[str]:
     """Name unnamed chart views
 
     Name unnamed charts views so that we can look them up later in
@@ -184,7 +184,7 @@ def name_views(
         chart, (_chart_class_mapping[Chart], _chart_class_mapping[FacetChart])
     ):
         if chart.name not in exclude:
-            if chart.name in (None, Undefined):
+            if chart.name in {None, Undefined}:
                 # Add name since none is specified
                 chart.name = Chart._get_name()
             return [chart.name]
@@ -200,20 +200,23 @@ def name_views(
         elif isinstance(chart, _chart_class_mapping[ConcatChart]):
             subcharts = chart.concat
         else:
-            raise ValueError(
+            msg = (
                 "transformed_data accepts an instance of "
                 "Chart, FacetChart, LayerChart, HConcatChart, VConcatChart, or ConcatChart\n"
                 f"Received value of type: {type(chart)}"
             )
+            raise ValueError(msg)
 
-        chart_names: List[str] = []
+        chart_names: list[str] = []
         for subchart in subcharts:
             for name in name_views(subchart, i=i + len(chart_names), exclude=exclude):
                 chart_names.append(name)
         return chart_names
 
 
-def get_group_mark_for_scope(vega_spec: dict, scope: Scope) -> Optional[dict]:
+def get_group_mark_for_scope(
+    vega_spec: dict[str, Any], scope: Scope
+) -> dict[str, Any] | None:
     """Get the group mark at a particular scope
 
     Parameters
@@ -266,7 +269,7 @@ def get_group_mark_for_scope(vega_spec: dict, scope: Scope) -> Optional[dict]:
     return group
 
 
-def get_datasets_for_scope(vega_spec: dict, scope: Scope) -> List[str]:
+def get_datasets_for_scope(vega_spec: dict[str, Any], scope: Scope) -> list[str]:
     """Get the names of the datasets that are defined at a given scope
 
     Parameters
@@ -336,8 +339,8 @@ def get_datasets_for_scope(vega_spec: dict, scope: Scope) -> List[str]:
 
 
 def get_definition_scope_for_data_reference(
-    vega_spec: dict, data_name: str, usage_scope: Scope
-) -> Optional[Scope]:
+    vega_spec: dict[str, Any], data_name: str, usage_scope: Scope
+) -> Scope | None:
     """Return the scope that a dataset is defined at, for a given usage scope
 
     Parameters
@@ -401,7 +404,7 @@ def get_definition_scope_for_data_reference(
     return None
 
 
-def get_facet_mapping(group: dict, scope: Scope = ()) -> FacetMapping:
+def get_facet_mapping(group: dict[str, Any], scope: Scope = ()) -> FacetMapping:
     """Create mapping from facet definitions to source datasets
 
     Parameters
@@ -444,7 +447,7 @@ def get_facet_mapping(group: dict, scope: Scope = ()) -> FacetMapping:
     for mark in mark_group.get("marks", []):
         if mark.get("type", None) == "group":
             # Get facet for this group
-            group_scope = scope + (group_index,)
+            group_scope = (*scope, group_index)
             facet = mark.get("from", {}).get("facet", None)
             if facet is not None:
                 facet_name = facet.get("name", None)
@@ -468,8 +471,8 @@ def get_facet_mapping(group: dict, scope: Scope = ()) -> FacetMapping:
 
 
 def get_from_facet_mapping(
-    scoped_dataset: Tuple[str, Scope], facet_mapping: FacetMapping
-) -> Tuple[str, Scope]:
+    scoped_dataset: tuple[str, Scope], facet_mapping: FacetMapping
+) -> tuple[str, Scope]:
     """Apply facet mapping to a scoped dataset
 
     Parameters
@@ -497,11 +500,11 @@ def get_from_facet_mapping(
 
 
 def get_datasets_for_view_names(
-    group: dict,
-    vl_chart_names: List[str],
+    group: dict[str, Any],
+    vl_chart_names: list[str],
     facet_mapping: FacetMapping,
     scope: Scope = (),
-) -> Dict[str, Tuple[str, Scope]]:
+) -> dict[str, tuple[str, Scope]]:
     """Get the Vega datasets that correspond to the provided Altair view names
 
     Parameters
@@ -536,7 +539,7 @@ def get_datasets_for_view_names(
         name = mark.get("name", "")
         if mark.get("type", "") == "group":
             group_data_names = get_datasets_for_view_names(
-                group, vl_chart_names, facet_mapping, scope=scope + (group_index,)
+                group, vl_chart_names, facet_mapping, scope=(*scope, group_index)
             )
             for k, v in group_data_names.items():
                 datasets.setdefault(k, v)
diff --git a/altair/utils/_vegafusion_data.py b/altair/utils/_vegafusion_data.py
index cfd8a5760..ea1ae6dad 100644
--- a/altair/utils/_vegafusion_data.py
+++ b/altair/utils/_vegafusion_data.py
@@ -3,10 +3,7 @@
 from weakref import WeakValueDictionary
 from typing import (
     Any,
-    Optional,
     Union,
-    Dict,
-    Set,
     MutableMapping,
     TypedDict,
     Final,
@@ -25,6 +22,7 @@
 )
 from altair.vegalite.data import default_data_transformer
 
+
 if TYPE_CHECKING:
     import pandas as pd
     from vegafusion.runtime import ChartState  # type: ignore
@@ -56,19 +54,19 @@ def vegafusion_data_transformer(
 
 @overload
 def vegafusion_data_transformer(
-    data: DataFrameLike, max_rows: int
+    data: DataFrameLike, max_rows: int = ...
 ) -> ToValuesReturnType: ...
 
 
 @overload
 def vegafusion_data_transformer(
-    data: Union[dict, pd.DataFrame, SupportsGeoInterface], max_rows: int
+    data: dict | pd.DataFrame | SupportsGeoInterface, max_rows: int = ...
 ) -> _VegaFusionReturnType: ...
 
 
 def vegafusion_data_transformer(
-    data: Optional[DataType] = None, max_rows: int = 100000
-) -> Union[Callable[..., Any], _VegaFusionReturnType]:
+    data: DataType | None = None, max_rows: int = 100000
+) -> Callable[..., Any] | _VegaFusionReturnType:
     """VegaFusion Data Transformer"""
     if data is None:
         return vegafusion_data_transformer
@@ -83,7 +81,7 @@ def vegafusion_data_transformer(
         return default_data_transformer(data)
 
 
-def get_inline_table_names(vega_spec: dict) -> Set[str]:
+def get_inline_table_names(vega_spec: dict[str, Any]) -> set[str]:
     """Get a set of the inline datasets names in the provided Vega spec
 
     Inline datasets are encoded as URLs that start with the table://
@@ -133,7 +131,7 @@ def get_inline_table_names(vega_spec: dict) -> Set[str]:
     return table_names
 
 
-def get_inline_tables(vega_spec: dict) -> Dict[str, DataFrameLike]:
+def get_inline_tables(vega_spec: dict[str, Any]) -> dict[str, DataFrameLike]:
     """Get the inline tables referenced by a Vega specification
 
     Note: This function should only be called on a Vega spec that corresponds
@@ -151,20 +149,16 @@ def get_inline_tables(vega_spec: dict) -> Dict[str, DataFrameLike]:
     dict from str to dataframe
         dict from inline dataset name to dataframe object
     """
-    table_names = get_inline_table_names(vega_spec)
-    tables = {}
-    for table_name in table_names:
-        try:
-            tables[table_name] = extracted_inline_tables.pop(table_name)
-        except KeyError:
-            # named dataset that was provided by the user
-            pass
-    return tables
+    inline_names = get_inline_table_names(vega_spec)
+    # exclude named dataset that was provided by the user,
+    # or dataframes that have been deleted.
+    table_names = inline_names.intersection(extracted_inline_tables)
+    return {k: extracted_inline_tables.pop(k) for k in table_names}
 
 
 def compile_to_vegafusion_chart_state(
-    vegalite_spec: dict, local_tz: str
-) -> "ChartState":
+    vegalite_spec: dict[str, Any], local_tz: str
+) -> ChartState:
     """Compile a Vega-Lite spec to a VegaFusion ChartState
 
     Note: This function should only be called on a Vega-Lite spec
@@ -193,7 +187,8 @@ def compile_to_vegafusion_chart_state(
     # Compile Vega-Lite spec to Vega
     compiler = vegalite_compilers.get()
     if compiler is None:
-        raise ValueError("No active vega-lite compiler plugin found")
+        msg = "No active vega-lite compiler plugin found"
+        raise ValueError(msg)
 
     vega_spec = compiler(vegalite_spec)
 
@@ -216,7 +211,7 @@ def compile_to_vegafusion_chart_state(
     return chart_state
 
 
-def compile_with_vegafusion(vegalite_spec: dict) -> dict:
+def compile_with_vegafusion(vegalite_spec: dict[str, Any]) -> dict:
     """Compile a Vega-Lite spec to Vega and pre-transform with VegaFusion
 
     Note: This function should only be called on a Vega-Lite spec
@@ -243,7 +238,8 @@ def compile_with_vegafusion(vegalite_spec: dict) -> dict:
     # Compile Vega-Lite spec to Vega
     compiler = vegalite_compilers.get()
     if compiler is None:
-        raise ValueError("No active vega-lite compiler plugin found")
+        msg = "No active vega-lite compiler plugin found"
+        raise ValueError(msg)
 
     vega_spec = compiler(vegalite_spec)
 
@@ -268,13 +264,14 @@ def compile_with_vegafusion(vegalite_spec: dict) -> dict:
 def handle_row_limit_exceeded(row_limit: int, warnings: list):
     for warning in warnings:
         if warning.get("type") == "RowLimitExceeded":
-            raise MaxRowsError(
+            msg = (
                 "The number of dataset rows after filtering and aggregation exceeds\n"
                 f"the current limit of {row_limit}. Try adding an aggregation to reduce\n"
                 "the size of the dataset that must be loaded into the browser. Or, disable\n"
                 "the limit by calling alt.data_transformers.disable_max_rows(). Note that\n"
                 "disabling this limit may cause the browser to freeze or crash."
             )
+            raise MaxRowsError(msg)
 
 
 def using_vegafusion() -> bool:
diff --git a/altair/utils/core.py b/altair/utils/core.py
index 88d03b6e7..71db80861 100644
--- a/altair/utils/core.py
+++ b/altair/utils/core.py
@@ -2,6 +2,8 @@
 Utility routines
 """
 
+from __future__ import annotations
+
 from collections.abc import Mapping, MutableMapping
 from copy import deepcopy
 import json
@@ -14,15 +16,13 @@
     Callable,
     TypeVar,
     Any,
-    Union,
-    Dict,
-    Optional,
-    Tuple,
     Sequence,
-    Type,
     cast,
+    Literal,
+    Protocol,
+    TYPE_CHECKING,
+    runtime_checkable,
 )
-from types import ModuleType
 
 import jsonschema
 import pandas as pd
@@ -37,10 +37,12 @@
 else:
     from typing_extensions import ParamSpec
 
-from typing import Literal, Protocol, TYPE_CHECKING, runtime_checkable
 
 if TYPE_CHECKING:
+    from types import ModuleType
+    import typing as t
     from pandas.core.interchange.dataframe_protocol import Column as PandasColumn
+    import pyarrow as pa
 
 V = TypeVar("V")
 P = ParamSpec("P")
@@ -199,7 +201,7 @@ def __dataframe__(
 
 def infer_vegalite_type(
     data: object,
-) -> Union[InferredVegaLiteType, Tuple[InferredVegaLiteType, list]]:
+) -> InferredVegaLiteType | tuple[InferredVegaLiteType, list[Any]]:
     """
     From an array-like input, infer the correct vega typecode
     ('ordinal', 'nominal', 'quantitative', or 'temporal')
@@ -210,19 +212,19 @@ def infer_vegalite_type(
     """
     typ = infer_dtype(data, skipna=False)
 
-    if typ in [
+    if typ in {
         "floating",
         "mixed-integer-float",
         "integer",
         "mixed-integer",
         "complex",
-    ]:
+    }:
         return "quantitative"
     elif typ == "categorical" and hasattr(data, "cat") and data.cat.ordered:
         return ("ordinal", data.cat.categories.tolist())
-    elif typ in ["string", "bytes", "categorical", "boolean", "mixed", "unicode"]:
+    elif typ in {"string", "bytes", "categorical", "boolean", "mixed", "unicode"}:
         return "nominal"
-    elif typ in [
+    elif typ in {
         "datetime",
         "datetime64",
         "timedelta",
@@ -230,18 +232,18 @@ def infer_vegalite_type(
         "date",
         "time",
         "period",
-    ]:
+    }:
         return "temporal"
     else:
         warnings.warn(
-            "I don't know how to infer vegalite type from '{}'.  "
-            "Defaulting to nominal.".format(typ),
+            f"I don't know how to infer vegalite type from '{typ}'.  "
+            "Defaulting to nominal.",
             stacklevel=1,
         )
         return "nominal"
 
 
-def merge_props_geom(feat: dict) -> dict:
+def merge_props_geom(feat: dict[str, Any]) -> dict[str, Any]:
     """
     Merge properties with geometry
     * Overwrites 'type' and 'geometry' entries if existing
@@ -259,7 +261,7 @@ def merge_props_geom(feat: dict) -> dict:
     return props_geom
 
 
-def sanitize_geo_interface(geo: MutableMapping) -> dict:
+def sanitize_geo_interface(geo: t.MutableMapping[Any, Any]) -> dict[str, Any]:
     """Santize a geo_interface to prepare it for serialization.
 
     * Make a copy
@@ -271,7 +273,7 @@ def sanitize_geo_interface(geo: MutableMapping) -> dict:
     geo = deepcopy(geo)
 
     # convert type _Array or array to list
-    for key in geo.keys():
+    for key in geo:
         if str(type(geo[key]).__name__).startswith(("_Array", "array")):
             geo[key] = geo[key].tolist()
 
@@ -299,7 +301,7 @@ def numpy_is_subtype(dtype: Any, subtype: Any) -> bool:
         return False
 
 
-def sanitize_dataframe(df: pd.DataFrame) -> pd.DataFrame:  # noqa: C901
+def sanitize_dataframe(df: pd.DataFrame) -> pd.DataFrame:
     """Sanitize a DataFrame to prepare it for serialization.
 
     * Make a copy
@@ -323,15 +325,18 @@ def sanitize_dataframe(df: pd.DataFrame) -> pd.DataFrame:  # noqa: C901
 
     for col_name in df.columns:
         if not isinstance(col_name, str):
-            raise ValueError(
-                "Dataframe contains invalid column name: {0!r}. "
-                "Column names must be strings".format(col_name)
+            msg = (
+                f"Dataframe contains invalid column name: {col_name!r}. "
+                "Column names must be strings"
             )
+            raise ValueError(msg)
 
     if isinstance(df.index, pd.MultiIndex):
-        raise ValueError("Hierarchical indices not supported")
+        msg = "Hierarchical indices not supported"
+        raise ValueError(msg)
     if isinstance(df.columns, pd.MultiIndex):
-        raise ValueError("Hierarchical indices not supported")
+        msg = "Hierarchical indices not supported"
+        raise ValueError(msg)
 
     def to_list_if_array(val):
         if isinstance(val, np.ndarray):
@@ -365,7 +370,7 @@ def to_list_if_array(val):
             # https://pandas.io/docs/user_guide/boolean.html
             col = df[col_name].astype(object)
             df[col_name] = col.where(col.notnull(), None)
-        elif dtype_name.startswith("datetime") or dtype_name.startswith("timestamp"):
+        elif dtype_name.startswith(("datetime", "timestamp")):
             # Convert datetimes to strings. This needs to be a full ISO string
             # with time, which is why we cannot use ``col.astype(str)``.
             # This is because Javascript parses date-only times in UTC, but
@@ -376,12 +381,13 @@ def to_list_if_array(val):
                 df[col_name].apply(lambda x: x.isoformat()).replace("NaT", "")
             )
         elif dtype_name.startswith("timedelta"):
-            raise ValueError(
-                'Field "{col_name}" has type "{dtype}" which is '
+            msg = (
+                f'Field "{col_name}" has type "{dtype}" which is '
                 "not supported by Altair. Please convert to "
                 "either a timestamp or a numerical value."
-                "".format(col_name=col_name, dtype=dtype)
+                ""
             )
+            raise ValueError(msg)
         elif dtype_name.startswith("geometry"):
             # geopandas >=0.6.1 uses the dtype geometry. Continue here
             # otherwise it will give an error on np.issubdtype(dtype, np.integer)
@@ -413,7 +419,7 @@ def to_list_if_array(val):
             col = df[col_name]
             bad_values = col.isnull() | np.isinf(col)
             df[col_name] = col.astype(object).where(~bad_values, None)
-        elif dtype == object:
+        elif dtype == object:  # noqa: E721
             # Convert numpy arrays saved as objects to lists
             # Arrays are not JSON serializable
             col = df[col_name].astype(object).apply(to_list_if_array)
@@ -421,7 +427,7 @@ def to_list_if_array(val):
     return df
 
 
-def sanitize_arrow_table(pa_table):
+def sanitize_arrow_table(pa_table: pa.Table) -> pa.Table:
     """Sanitize arrow table for JSON serialization"""
     import pyarrow as pa
     import pyarrow.compute as pc
@@ -431,15 +437,16 @@ def sanitize_arrow_table(pa_table):
     for name in schema.names:
         array = pa_table[name]
         dtype_name = str(schema.field(name).type)
-        if dtype_name.startswith("timestamp") or dtype_name.startswith("date"):
+        if dtype_name.startswith(("timestamp", "date")):
             arrays.append(pc.strftime(array))
         elif dtype_name.startswith("duration"):
-            raise ValueError(
-                'Field "{col_name}" has type "{dtype}" which is '
+            msg = (
+                f'Field "{name}" has type "{dtype_name}" which is '
                 "not supported by Altair. Please convert to "
                 "either a timestamp or a numerical value."
-                "".format(col_name=name, dtype=dtype_name)
+                ""
             )
+            raise ValueError(msg)
         else:
             arrays.append(array)
 
@@ -447,13 +454,13 @@ def sanitize_arrow_table(pa_table):
 
 
 def parse_shorthand(
-    shorthand: Union[Dict[str, Any], str],
-    data: Optional[Union[pd.DataFrame, DataFrameLike]] = None,
+    shorthand: dict[str, Any] | str,
+    data: pd.DataFrame | DataFrameLike | None = None,
     parse_aggregates: bool = True,
     parse_window_ops: bool = False,
     parse_timeunits: bool = True,
     parse_types: bool = True,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """General tool to parse shorthand values
 
     These are of the form:
@@ -642,8 +649,8 @@ def parse_shorthand(
 
 
 def infer_vegalite_type_for_dfi_column(
-    column: Union[Column, "PandasColumn"],
-) -> Union[InferredVegaLiteType, Tuple[InferredVegaLiteType, list]]:
+    column: Column | PandasColumn,
+) -> InferredVegaLiteType | tuple[InferredVegaLiteType, list[Any]]:
     from pyarrow.interchange.from_dataframe import column_to_array
 
     try:
@@ -668,17 +675,18 @@ def infer_vegalite_type_for_dfi_column(
         categories_column = column.describe_categorical["categories"]
         categories_array = column_to_array(categories_column)
         return "ordinal", categories_array.to_pylist()
-    if kind in (DtypeKind.STRING, DtypeKind.CATEGORICAL, DtypeKind.BOOL):
+    if kind in {DtypeKind.STRING, DtypeKind.CATEGORICAL, DtypeKind.BOOL}:
         return "nominal"
-    elif kind in (DtypeKind.INT, DtypeKind.UINT, DtypeKind.FLOAT):
+    elif kind in {DtypeKind.INT, DtypeKind.UINT, DtypeKind.FLOAT}:
         return "quantitative"
     elif kind == DtypeKind.DATETIME:
         return "temporal"
     else:
-        raise ValueError(f"Unexpected DtypeKind: {kind}")
+        msg = f"Unexpected DtypeKind: {kind}"
+        raise ValueError(msg)
 
 
-def use_signature(Obj: Callable[P, Any]):
+def use_signature(Obj: Callable[P, Any]):  # -> Callable[..., Callable[P, V]]:
     """Apply call signature and documentation of Obj to the decorated method"""
 
     def decorate(f: Callable[..., V]) -> Callable[P, V]:
@@ -698,11 +706,7 @@ def decorate(f: Callable[..., V]) -> Callable[P, V]:
                 doc = f.__doc__ + "\n".join(doclines[1:])
             else:
                 doc = "\n".join(doclines)
-            try:
-                f.__doc__ = doc
-            except AttributeError:
-                # __doc__ is not modifiable for classes in Python < 3.3
-                pass
+            f.__doc__ = doc
 
         return f
 
@@ -710,8 +714,10 @@ def decorate(f: Callable[..., V]) -> Callable[P, V]:
 
 
 def update_nested(
-    original: MutableMapping, update: Mapping, copy: bool = False
-) -> MutableMapping:
+    original: t.MutableMapping[Any, Any],
+    update: t.Mapping[Any, Any],
+    copy: bool = False,
+) -> t.MutableMapping[Any, Any]:
     """Update nested dictionaries
 
     Parameters
@@ -767,7 +773,9 @@ def display_traceback(in_ipython: bool = True):
         traceback.print_exception(*exc_info)
 
 
-def infer_encoding_types(args: Sequence, kwargs: MutableMapping, channels: ModuleType):
+def infer_encoding_types(
+    args: Sequence[Any], kwargs: t.MutableMapping[str, Any], channels: ModuleType
+) -> dict[str, SchemaBase | list | dict[str, str] | Any]:
     """Infer typed keyword arguments for args and kwargs
 
     Parameters
@@ -791,10 +799,10 @@ def infer_encoding_types(args: Sequence, kwargs: MutableMapping, channels: Modul
     channel_objs = (
         c for c in channel_objs if isinstance(c, type) and issubclass(c, SchemaBase)
     )
-    channel_to_name: Dict[Type[SchemaBase], str] = {
+    channel_to_name: dict[type[SchemaBase], str] = {
         c: c._encoding_name for c in channel_objs
     }
-    name_to_channel: Dict[str, Dict[str, Type[SchemaBase]]] = {}
+    name_to_channel: dict[str, dict[str, type[SchemaBase]]] = {}
     for chan, name in channel_to_name.items():
         chans = name_to_channel.setdefault(name, {})
         if chan.__name__.endswith("Datum"):
@@ -812,11 +820,13 @@ def infer_encoding_types(args: Sequence, kwargs: MutableMapping, channels: Modul
         else:
             type_ = type(arg)
 
-        encoding = channel_to_name.get(type_, None)
+        encoding = channel_to_name.get(type_)
         if encoding is None:
-            raise NotImplementedError("positional of type {}" "".format(type_))
+            msg = f"positional of type {type_}" ""
+            raise NotImplementedError(msg)
         if encoding in kwargs:
-            raise ValueError("encoding {} specified twice.".format(encoding))
+            msg = f"encoding {encoding} specified twice."
+            raise ValueError(msg)
         kwargs[encoding] = arg
 
     def _wrap_in_channel_class(obj, encoding):
@@ -830,9 +840,7 @@ def _wrap_in_channel_class(obj, encoding):
             return [_wrap_in_channel_class(subobj, encoding) for subobj in obj]
 
         if encoding not in name_to_channel:
-            warnings.warn(
-                "Unrecognized encoding channel '{}'".format(encoding), stacklevel=1
-            )
+            warnings.warn(f"Unrecognized encoding channel '{encoding}'", stacklevel=1)
             return obj
 
         classes = name_to_channel[encoding]
diff --git a/altair/utils/data.py b/altair/utils/data.py
index 41b5e71aa..8ab46a6f7 100644
--- a/altair/utils/data.py
+++ b/altair/utils/data.py
@@ -1,25 +1,27 @@
-from functools import partial
+from __future__ import annotations
 import json
 import random
 import hashlib
-import sys
-from pathlib import Path
 from typing import (
-    Union,
+    Any,
+    List,
     MutableMapping,
-    Optional,
-    Dict,
     Sequence,
     TYPE_CHECKING,
-    List,
-    TypeVar,
     Protocol,
     TypedDict,
     Literal,
+    TypeVar,
+    Union,
+    Dict,
+    Optional,
     overload,
     runtime_checkable,
-    Any,
 )
+from typing_extensions import TypeAlias
+from pathlib import Path
+from functools import partial
+import sys
 
 import pandas as pd
 
@@ -34,7 +36,7 @@
     from typing_extensions import TypeIs
 
 if TYPE_CHECKING:
-    import pyarrow.lib
+    import pyarrow as pa
 
 
 @runtime_checkable
@@ -42,14 +44,17 @@ class SupportsGeoInterface(Protocol):
     __geo_interface__: MutableMapping
 
 
-DataType = Union[dict, pd.DataFrame, SupportsGeoInterface, DataFrameLike]
+DataType: TypeAlias = Union[
+    Dict[Any, Any], pd.DataFrame, SupportsGeoInterface, DataFrameLike
+]
+
 TDataType = TypeVar("TDataType", bound=DataType)
 
-VegaLiteDataDict = Dict[str, Union[str, dict, List[dict]]]
-ToValuesReturnType = Dict[str, Union[dict, List[dict]]]
-SampleReturnType = Optional[
-    Union[pd.DataFrame, Dict[str, Sequence], "pyarrow.lib.Table"]
+VegaLiteDataDict: TypeAlias = Dict[
+    str, Union[str, Dict[Any, Any], List[Dict[Any, Any]]]
 ]
+ToValuesReturnType: TypeAlias = Dict[str, Union[Dict[Any, Any], List[Dict[Any, Any]]]]
+SampleReturnType = Optional[Union[pd.DataFrame, Dict[str, Sequence], "pa.lib.Table"]]
 
 
 def is_data_type(obj: Any) -> TypeIs[DataType]:
@@ -69,12 +74,12 @@ def is_data_type(obj: Any) -> TypeIs[DataType]:
 # ==============================================================================
 class DataTransformerType(Protocol):
     @overload
-    def __call__(self, data: None = None, **kwargs) -> "DataTransformerType": ...
+    def __call__(self, data: None = None, **kwargs) -> DataTransformerType: ...
     @overload
     def __call__(self, data: DataType, **kwargs) -> VegaLiteDataDict: ...
     def __call__(
-        self, data: Optional[DataType] = None, **kwargs
-    ) -> Union["DataTransformerType", VegaLiteDataDict]: ...
+        self, data: DataType | None = None, **kwargs
+    ) -> DataTransformerType | VegaLiteDataDict: ...
 
 
 class DataTransformerRegistry(PluginRegistry[DataTransformerType]):
@@ -93,16 +98,14 @@ def consolidate_datasets(self, value: bool) -> None:
 class MaxRowsError(Exception):
     """Raised when a data model has too many rows."""
 
-    pass
-
 
 @overload
-def limit_rows(data: None = ..., max_rows: Optional[int] = ...) -> partial: ...
+def limit_rows(data: None = ..., max_rows: int | None = ...) -> partial: ...
 @overload
-def limit_rows(data: DataType, max_rows: Optional[int] = ...) -> DataType: ...
+def limit_rows(data: DataType, max_rows: int | None = ...) -> DataType: ...
 def limit_rows(
-    data: Optional[DataType] = None, max_rows: Optional[int] = 5000
-) -> Union[partial, DataType]:
+    data: DataType | None = None, max_rows: int | None = 5000
+) -> partial | DataType:
     """Raise MaxRowsError if the data model has more than max_rows.
 
     If max_rows is None, then do not perform any check.
@@ -112,7 +115,7 @@ def limit_rows(
     check_data_type(data)
 
     def raise_max_rows_error():
-        raise MaxRowsError(
+        msg = (
             "The number of rows in your dataset is greater "
             f"than the maximum allowed ({max_rows}).\n\n"
             "Try enabling the VegaFusion data transformer which "
@@ -124,6 +127,7 @@ def raise_max_rows_error():
             "for additional information\n"
             "on how to plot large datasets."
         )
+        raise MaxRowsError(msg)
 
     if isinstance(data, SupportsGeoInterface):
         if data.__geo_interface__["type"] == "FeatureCollection":
@@ -153,17 +157,17 @@ def raise_max_rows_error():
 
 @overload
 def sample(
-    data: None = ..., n: Optional[int] = ..., frac: Optional[float] = ...
+    data: None = ..., n: int | None = ..., frac: float | None = ...
 ) -> partial: ...
 @overload
 def sample(
-    data: DataType, n: Optional[int], frac: Optional[float]
+    data: DataType, n: int | None = ..., frac: float | None = ...
 ) -> SampleReturnType: ...
 def sample(
-    data: Optional[DataType] = None,
-    n: Optional[int] = None,
-    frac: Optional[float] = None,
-) -> Union[partial, SampleReturnType]:
+    data: DataType | None = None,
+    n: int | None = None,
+    frac: float | None = None,
+) -> partial | SampleReturnType:
     """Reduce the size of the data model by sampling without replacement."""
     if data is None:
         return partial(sample, n=n, frac=frac)
@@ -175,9 +179,8 @@ def sample(
             values = data["values"]
             if not n:
                 if frac is None:
-                    raise ValueError(
-                        "frac cannot be None if n is None and data is a dictionary"
-                    )
+                    msg = "frac cannot be None if n is None and data is a dictionary"
+                    raise ValueError(msg)
                 n = int(frac * len(values))
             values = random.sample(values, n)
             return {"values": values}
@@ -188,9 +191,8 @@ def sample(
         pa_table = arrow_table_from_dfi_dataframe(data)
         if not n:
             if frac is None:
-                raise ValueError(
-                    "frac cannot be None if n is None with this data input type"
-                )
+                msg = "frac cannot be None if n is None with this data input type"
+                raise ValueError(msg)
             n = int(frac * len(pa_table))
         indices = random.sample(range(len(pa_table)), n)
         return pa_table.take(indices)
@@ -233,12 +235,12 @@ def to_json(
 
 
 def to_json(
-    data: Optional[DataType] = None,
+    data: DataType | None = None,
     prefix: str = "altair-data",
     extension: str = "json",
     filename: str = "{prefix}-{hash}.{extension}",
     urlpath: str = "",
-) -> Union[partial, _ToFormatReturnUrlDict]:
+) -> partial | _ToFormatReturnUrlDict:
     """
     Write the data model to a .json file and return a url based data model.
     """
@@ -262,7 +264,7 @@ def to_csv(
 
 @overload
 def to_csv(
-    data: Union[dict, pd.DataFrame, DataFrameLike],
+    data: dict | pd.DataFrame | DataFrameLike,
     prefix: str = ...,
     extension: str = ...,
     filename: str = ...,
@@ -271,12 +273,12 @@ def to_csv(
 
 
 def to_csv(
-    data: Optional[Union[dict, pd.DataFrame, DataFrameLike]] = None,
+    data: dict | pd.DataFrame | DataFrameLike | None = None,
     prefix: str = "altair-data",
     extension: str = "csv",
     filename: str = "{prefix}-{hash}.{extension}",
     urlpath: str = "",
-) -> Union[partial, _ToFormatReturnUrlDict]:
+) -> partial | _ToFormatReturnUrlDict:
     """Write the data model to a .csv file and return a url based data model."""
     kwds = _to_text_kwds(prefix, extension, filename, urlpath)
     if data is None:
@@ -296,12 +298,12 @@ def _to_text(
 ) -> _ToFormatReturnUrlDict:
     data_hash = _compute_data_hash(data)
     filename = filename.format(prefix=prefix, hash=data_hash, extension=extension)
-    Path(filename).write_text(data)
+    Path(filename).write_text(data, encoding="utf-8")
     url = str(Path(urlpath, filename))
     return _ToFormatReturnUrlDict({"url": url, "format": format})
 
 
-def _to_text_kwds(prefix: str, extension: str, filename: str, urlpath: str, /) -> Dict[str, str]:  # fmt: skip
+def _to_text_kwds(prefix: str, extension: str, filename: str, urlpath: str, /) -> dict[str, str]:  # fmt: skip
     return {"prefix": prefix, "extension": extension, "filename": filename, "urlpath": urlpath}  # fmt: skip
 
 
@@ -320,23 +322,22 @@ def to_values(data: DataType) -> ToValuesReturnType:
         return {"values": data.to_dict(orient="records")}
     elif isinstance(data, dict):
         if "values" not in data:
-            raise KeyError("values expected in data dict, but not present.")
+            msg = "values expected in data dict, but not present."
+            raise KeyError(msg)
         return data
     elif isinstance(data, DataFrameLike):
         pa_table = sanitize_arrow_table(arrow_table_from_dfi_dataframe(data))
         return {"values": pa_table.to_pylist()}
     else:
         # Should never reach this state as tested by check_data_type
-        raise ValueError("Unrecognized data type: {}".format(type(data)))
+        msg = f"Unrecognized data type: {type(data)}"
+        raise ValueError(msg)
 
 
 def check_data_type(data: DataType) -> None:
     if not is_data_type(data):
-        raise TypeError(
-            "Expected dict, DataFrame or a __geo_interface__ attribute, got: {}".format(
-                type(data)
-            )
-        )
+        msg = f"Expected dict, DataFrame or a __geo_interface__ attribute, got: {type(data)}"
+        raise TypeError(msg)
 
 
 # ==============================================================================
@@ -361,32 +362,34 @@ def _data_to_json_string(data: DataType) -> str:
         return data.to_json(orient="records", double_precision=15)
     elif isinstance(data, dict):
         if "values" not in data:
-            raise KeyError("values expected in data dict, but not present.")
+            msg = "values expected in data dict, but not present."
+            raise KeyError(msg)
         return json.dumps(data["values"], sort_keys=True)
     elif isinstance(data, DataFrameLike):
         pa_table = arrow_table_from_dfi_dataframe(data)
         return json.dumps(pa_table.to_pylist())
     else:
-        raise NotImplementedError(
-            "to_json only works with data expressed as " "a DataFrame or as a dict"
-        )
+        msg = "to_json only works with data expressed as " "a DataFrame or as a dict"
+        raise NotImplementedError(msg)
 
 
-def _data_to_csv_string(data: Union[dict, pd.DataFrame, DataFrameLike]) -> str:
+def _data_to_csv_string(data: dict | pd.DataFrame | DataFrameLike) -> str:
     """return a CSV string representation of the input data"""
     check_data_type(data)
     if isinstance(data, SupportsGeoInterface):
-        raise NotImplementedError(
+        msg = (
             f"to_csv does not yet work with data that "
             f"is of type {type(SupportsGeoInterface).__name__!r}.\n"
             f"See https://github.com/vega/altair/issues/3441"
         )
+        raise NotImplementedError(msg)
     elif isinstance(data, pd.DataFrame):
         data = sanitize_dataframe(data)
         return data.to_csv(index=False)
     elif isinstance(data, dict):
         if "values" not in data:
-            raise KeyError("values expected in data dict, but not present")
+            msg = "values expected in data dict, but not present"
+            raise KeyError(msg)
         return pd.DataFrame.from_dict(data["values"]).to_csv(index=False)
     elif isinstance(data, DataFrameLike):
         # experimental interchange dataframe support
@@ -398,12 +401,11 @@ def _data_to_csv_string(data: Union[dict, pd.DataFrame, DataFrameLike]) -> str:
         pa_csv.write_csv(pa_table, csv_buffer)
         return csv_buffer.getvalue().to_pybytes().decode()
     else:
-        raise NotImplementedError(
-            "to_csv only works with data expressed as " "a DataFrame or as a dict"
-        )
+        msg = "to_csv only works with data expressed as " "a DataFrame or as a dict"
+        raise NotImplementedError(msg)
 
 
-def arrow_table_from_dfi_dataframe(dfi_df: DataFrameLike) -> "pyarrow.lib.Table":
+def arrow_table_from_dfi_dataframe(dfi_df: DataFrameLike) -> pa.Table:
     """Convert a DataFrame Interchange Protocol compatible object to an Arrow Table"""
     import pyarrow as pa
 
diff --git a/altair/utils/deprecation.py b/altair/utils/deprecation.py
index f0ed26ae9..b247e3a4b 100644
--- a/altair/utils/deprecation.py
+++ b/altair/utils/deprecation.py
@@ -1,12 +1,30 @@
+from __future__ import annotations
+
+import sys
+from typing import Callable, TypeVar, TYPE_CHECKING
 import warnings
 import functools
 
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
+else:
+    from typing_extensions import ParamSpec
+
+if TYPE_CHECKING:
+    from functools import _Wrapped
+
+T = TypeVar("T")
+P = ParamSpec("P")
+R = TypeVar("R")
+
 
 class AltairDeprecationWarning(UserWarning):
     pass
 
 
-def deprecated(message=None):
+def deprecated(
+    message: str | None = None,
+) -> Callable[..., type[T] | _Wrapped[P, R, P, R]]:
     """Decorator to deprecate a function or class.
 
     Parameters
@@ -15,13 +33,15 @@ def deprecated(message=None):
         The deprecation message
     """
 
-    def wrapper(obj):
+    def wrapper(obj: type[T] | Callable[P, R]) -> type[T] | _Wrapped[P, R, P, R]:
         return _deprecate(obj, message=message)
 
     return wrapper
 
 
-def _deprecate(obj, name=None, message=None):
+def _deprecate(
+    obj: type[T] | Callable[P, R], name: str | None = None, message: str | None = None
+) -> type[T] | _Wrapped[P, R, P, R]:
     """Return a version of a class or function that raises a deprecation warning.
 
     Parameters
@@ -46,26 +66,29 @@ def _deprecate(obj, name=None, message=None):
     AltairDeprecationWarning: alt.OldFoo is deprecated. Use alt.Foo instead.
     """
     if message is None:
-        message = "alt.{} is deprecated. Use alt.{} instead." "".format(
-            name, obj.__name__
-        )
+        message = f"alt.{name} is deprecated. Use alt.{obj.__name__} instead." ""
     if isinstance(obj, type):
-        return type(
-            name,
-            (obj,),
-            {
-                "__doc__": obj.__doc__,
-                "__init__": _deprecate(obj.__init__, "__init__", message),
-            },
-        )
+        if name is None:
+            msg = f"Requires name, but got: {name=}"
+            raise TypeError(msg)
+        else:
+            return type(
+                name,
+                (obj,),
+                {
+                    "__doc__": obj.__doc__,
+                    "__init__": _deprecate(obj.__init__, "__init__", message),
+                },
+            )
     elif callable(obj):
 
         @functools.wraps(obj)
-        def new_obj(*args, **kwargs):
+        def new_obj(*args: P.args, **kwargs: P.kwargs) -> R:
             warnings.warn(message, AltairDeprecationWarning, stacklevel=1)
             return obj(*args, **kwargs)
 
-        new_obj._deprecated = True
+        new_obj._deprecated = True  # type: ignore[attr-defined]
         return new_obj
     else:
-        raise ValueError("Cannot deprecate object of type {}".format(type(obj)))
+        msg = f"Cannot deprecate object of type {type(obj)}"
+        raise ValueError(msg)
diff --git a/altair/utils/display.py b/altair/utils/display.py
index 30c31d4ad..2078c61de 100644
--- a/altair/utils/display.py
+++ b/altair/utils/display.py
@@ -1,7 +1,9 @@
+from __future__ import annotations
 import json
 import pkgutil
 import textwrap
-from typing import Callable, Dict, Optional, Tuple, Any, Union
+from typing import Callable, Any, Dict, Tuple, Union
+from typing_extensions import TypeAlias
 import uuid
 
 from ._vegafusion_data import compile_with_vegafusion, using_vegafusion
@@ -16,15 +18,16 @@
 # MimeBundleType needs to be the same as what are acceptable return values
 # for _repr_mimebundle_,
 # see https://ipython.readthedocs.io/en/stable/config/integrating.html#MyObject._repr_mimebundle_
-MimeBundleDataType = Dict[str, Any]
-MimeBundleMetaDataType = Dict[str, Any]
-MimeBundleType = Union[
+MimeBundleDataType: TypeAlias = Dict[str, Any]
+MimeBundleMetaDataType: TypeAlias = Dict[str, Any]
+MimeBundleType: TypeAlias = Union[
     MimeBundleDataType, Tuple[MimeBundleDataType, MimeBundleMetaDataType]
 ]
-RendererType = Callable[..., MimeBundleType]
+RendererType: TypeAlias = Callable[..., MimeBundleType]
 # Subtype of MimeBundleType as more specific in the values of the dictionaries
-DefaultRendererReturnType = Tuple[
-    Dict[str, Union[str, dict]], Dict[str, Dict[str, Any]]
+
+DefaultRendererReturnType: TypeAlias = Tuple[
+    Dict[str, Union[str, Dict[str, Any]]], Dict[str, Dict[str, Any]]
 ]
 
 
@@ -42,15 +45,15 @@ class RendererRegistry(PluginRegistry[RendererType]):
 
     def set_embed_options(
         self,
-        defaultStyle: Optional[Union[bool, str]] = None,
-        renderer: Optional[str] = None,
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-        padding: Optional[int] = None,
-        scaleFactor: Optional[float] = None,
-        actions: Optional[Union[bool, Dict[str, bool]]] = None,
-        format_locale: Optional[Union[str, dict]] = None,
-        time_format_locale: Optional[Union[str, dict]] = None,
+        defaultStyle: bool | str | None = None,
+        renderer: str | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        padding: int | None = None,
+        scaleFactor: float | None = None,
+        actions: bool | dict[str, bool] | None = None,
+        format_locale: str | dict | None = None,
+        time_format_locale: str | dict | None = None,
         **kwargs,
     ) -> PluginEnabler:
         """Set options for embeddings of Vega & Vega-Lite charts.
@@ -94,7 +97,7 @@ def set_embed_options(
         **kwargs :
             Additional options are passed directly to embed options.
         """
-        options: Dict[str, Optional[Union[bool, str, float, Dict[str, bool]]]] = {
+        options: dict[str, bool | str | float | dict[str, bool] | None] = {
             "defaultStyle": defaultStyle,
             "renderer": renderer,
             "width": width,
@@ -129,10 +132,10 @@ class Displayable:
     through appropriate data model transformers.
     """
 
-    renderers: Optional[RendererRegistry] = None
+    renderers: RendererRegistry | None = None
     schema_path = ("altair", "")
 
-    def __init__(self, spec: dict, validate: bool = False) -> None:
+    def __init__(self, spec: dict[str, Any], validate: bool = False) -> None:
         self.spec = spec
         self.validate = validate
         self._validate()
@@ -141,7 +144,7 @@ def _validate(self) -> None:
         """Validate the spec against the schema."""
         data = pkgutil.get_data(*self.schema_path)
         assert data is not None
-        schema_dict: dict = json.loads(data.decode("utf-8"))
+        schema_dict: dict[str, Any] = json.loads(data.decode("utf-8"))
         validate_jsonschema(
             self.spec,
             schema_dict,
@@ -160,7 +163,7 @@ def _repr_mimebundle_(
 
 
 def default_renderer_base(
-    spec: dict, mime_type: str, str_repr: str, **options
+    spec: dict[str, Any], mime_type: str, str_repr: str, **options
 ) -> DefaultRendererReturnType:
     """A default renderer for Vega or VegaLite that works for modern frontends.
 
@@ -171,8 +174,8 @@ def default_renderer_base(
     from altair.vegalite.v5.display import VEGA_MIME_TYPE, VEGALITE_MIME_TYPE
 
     assert isinstance(spec, dict)
-    bundle: Dict[str, Union[str, dict]] = {}
-    metadata: Dict[str, Dict[str, Any]] = {}
+    bundle: dict[str, str | dict] = {}
+    metadata: dict[str, dict[str, Any]] = {}
 
     if using_vegafusion():
         spec = compile_with_vegafusion(spec)
@@ -190,7 +193,7 @@ def default_renderer_base(
 
 
 def json_renderer_base(
-    spec: dict, str_repr: str, **options
+    spec: dict[str, Any], str_repr: str, **options
 ) -> DefaultRendererReturnType:
     """A renderer that returns a MIME type of application/json.
 
@@ -212,11 +215,7 @@ def __init__(self, output_div: str = "altair-viz-{}", **kwargs) -> None:
     def output_div(self) -> str:
         return self._output_div.format(uuid.uuid4().hex)
 
-    def __call__(self, spec: dict, **metadata) -> Dict[str, str]:
+    def __call__(self, spec: dict[str, Any], **metadata) -> dict[str, str]:
         kwargs = self.kwargs.copy()
-        kwargs.update(metadata)
-        # To get proper return value type, would need to write complex
-        # overload signatures for spec_to_mimebundle based on `format`
-        return spec_to_mimebundle(  # type: ignore[return-value]
-            spec, format="html", output_div=self.output_div, **kwargs
-        )
+        kwargs.update(**metadata, output_div=self.output_div)
+        return spec_to_mimebundle(spec, format="html", **kwargs)
diff --git a/altair/utils/html.py b/altair/utils/html.py
index 6cd89b2dd..5780eca8f 100644
--- a/altair/utils/html.py
+++ b/altair/utils/html.py
@@ -1,10 +1,15 @@
+from __future__ import annotations
+
 import json
-from typing import Optional, Dict
+from typing import Any, Literal
 
 import jinja2
 
 from altair.utils._importers import import_vl_convert, vl_version_for_vl_convert
 
+TemplateName = Literal["standard", "universal", "inline"]
+RenderMode = Literal["vega", "vega-lite"]
+
 HTML_TEMPLATE = jinja2.Template(
     """
 {%- if fullhtml -%}
@@ -200,7 +205,7 @@
 )
 
 
-TEMPLATES: Dict[str, jinja2.Template] = {
+TEMPLATES: dict[TemplateName, jinja2.Template] = {
     "standard": HTML_TEMPLATE,
     "universal": HTML_TEMPLATE_UNIVERSAL,
     "inline": INLINE_HTML_TEMPLATE,
@@ -208,18 +213,18 @@
 
 
 def spec_to_html(
-    spec: dict,
-    mode: str,
-    vega_version: Optional[str],
-    vegaembed_version: Optional[str],
-    vegalite_version: Optional[str] = None,
+    spec: dict[str, Any],
+    mode: RenderMode,
+    vega_version: str | None,
+    vegaembed_version: str | None,
+    vegalite_version: str | None = None,
     base_url: str = "https://cdn.jsdelivr.net/npm",
     output_div: str = "vis",
-    embed_options: Optional[dict] = None,
-    json_kwds: Optional[dict] = None,
+    embed_options: dict[str, Any] | None = None,
+    json_kwds: dict[str, Any] | None = None,
     fullhtml: bool = True,
     requirejs: bool = False,
-    template: str = "standard",
+    template: jinja2.Template | TemplateName = "standard",
 ) -> str:
     """Embed a Vega/Vega-Lite spec into an HTML page
 
@@ -266,17 +271,21 @@ def spec_to_html(
 
     mode = embed_options.setdefault("mode", mode)
 
-    if mode not in ["vega", "vega-lite"]:
-        raise ValueError("mode must be either 'vega' or 'vega-lite'")
+    if mode not in {"vega", "vega-lite"}:
+        msg = "mode must be either 'vega' or 'vega-lite'"
+        raise ValueError(msg)
 
     if vega_version is None:
-        raise ValueError("must specify vega_version")
+        msg = "must specify vega_version"
+        raise ValueError(msg)
 
     if vegaembed_version is None:
-        raise ValueError("must specify vegaembed_version")
+        msg = "must specify vegaembed_version"
+        raise ValueError(msg)
 
     if mode == "vega-lite" and vegalite_version is None:
-        raise ValueError("must specify vega-lite version for mode='vega-lite'")
+        msg = "must specify vega-lite version for mode='vega-lite'"
+        raise ValueError(msg)
 
     render_kwargs = {}
     if template == "inline":
@@ -284,9 +293,10 @@ def spec_to_html(
         vl_version = vl_version_for_vl_convert()
         render_kwargs["vegaembed_script"] = vlc.javascript_bundle(vl_version=vl_version)
 
-    jinja_template = TEMPLATES.get(template, template)
+    jinja_template = TEMPLATES.get(template, template)  # type: ignore[arg-type]
     if not hasattr(jinja_template, "render"):
-        raise ValueError("Invalid template: {0}".format(jinja_template))
+        msg = f"Invalid template: {jinja_template}"
+        raise ValueError(msg)
 
     return jinja_template.render(
         spec=json.dumps(spec, **json_kwds),
diff --git a/altair/utils/mimebundle.py b/altair/utils/mimebundle.py
index 89588d04d..33af5ae30 100644
--- a/altair/utils/mimebundle.py
+++ b/altair/utils/mimebundle.py
@@ -1,21 +1,74 @@
-from typing import Literal, Optional, Union, cast, Tuple
-
+from __future__ import annotations
+from typing import Any, Literal, cast, overload
+from typing_extensions import TypeAlias
 from .html import spec_to_html
 from ._importers import import_vl_convert, vl_version_for_vl_convert
 import struct
 
+MimeBundleFormat: TypeAlias = Literal[
+    "html", "json", "png", "svg", "pdf", "vega", "vega-lite"
+]
+
 
+@overload
 def spec_to_mimebundle(
-    spec: dict,
-    format: Literal["html", "json", "png", "svg", "pdf", "vega", "vega-lite"],
-    mode: Optional[Literal["vega-lite"]] = None,
-    vega_version: Optional[str] = None,
-    vegaembed_version: Optional[str] = None,
-    vegalite_version: Optional[str] = None,
-    embed_options: Optional[dict] = None,
-    engine: Optional[Literal["vl-convert"]] = None,
+    spec: dict[str, Any],
+    format: Literal["json", "vega-lite"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> dict[str, dict[str, Any]]: ...
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["html"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
     **kwargs,
-) -> Union[dict, Tuple[dict, dict]]:
+) -> dict[str, str]: ...
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["pdf", "svg", "vega"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> dict[str, Any]: ...
+@overload
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: Literal["png"],
+    mode: Literal["vega-lite"] | None = ...,
+    vega_version: str | None = ...,
+    vegaembed_version: str | None = ...,
+    vegalite_version: str | None = ...,
+    embed_options: dict[str, Any] | None = ...,
+    engine: Literal["vl-convert"] | None = ...,
+    **kwargs,
+) -> tuple[dict[str, Any], dict[str, Any]]: ...
+def spec_to_mimebundle(
+    spec: dict[str, Any],
+    format: MimeBundleFormat,
+    mode: Literal["vega-lite"] | None = None,
+    vega_version: str | None = None,
+    vegaembed_version: str | None = None,
+    vegalite_version: str | None = None,
+    embed_options: dict[str, Any] | None = None,
+    engine: Literal["vl-convert"] | None = None,
+    **kwargs,
+) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any]]:
     """Convert a vega-lite specification to a mimebundle
 
     The mimebundle type is controlled by the ``format`` argument, which can be
@@ -61,7 +114,8 @@ def spec_to_mimebundle(
     from altair import renderers
 
     if mode != "vega-lite":
-        raise ValueError("mode must be 'vega-lite'")
+        msg = "mode must be 'vega-lite'"
+        raise ValueError(msg)
 
     internal_mode: Literal["vega-lite", "vega"] = mode
     if using_vegafusion():
@@ -76,18 +130,17 @@ def spec_to_mimebundle(
 
     embed_options = preprocess_embed_options(final_embed_options)
 
-    if format in ["png", "svg", "pdf", "vega"]:
-        format = cast(Literal["png", "svg", "pdf", "vega"], format)
+    if format in {"png", "svg", "pdf", "vega"}:
         return _spec_to_mimebundle_with_engine(
             spec,
-            format,
+            cast(Literal["png", "svg", "pdf", "vega"], format),
             internal_mode,
             engine=engine,
             format_locale=embed_options.get("formatLocale", None),
             time_format_locale=embed_options.get("timeFormatLocale", None),
             **kwargs,
         )
-    if format == "html":
+    elif format == "html":
         html = spec_to_html(
             spec,
             mode=internal_mode,
@@ -98,26 +151,29 @@ def spec_to_mimebundle(
             **kwargs,
         )
         return {"text/html": html}
-    if format == "vega-lite":
+    elif format == "vega-lite":
         if vegalite_version is None:
-            raise ValueError("Must specify vegalite_version")
-        return {"application/vnd.vegalite.v{}+json".format(vegalite_version[0]): spec}
-    if format == "json":
+            msg = "Must specify vegalite_version"
+            raise ValueError(msg)
+        return {f"application/vnd.vegalite.v{vegalite_version[0]}+json": spec}
+    elif format == "json":
         return {"application/json": spec}
-    raise ValueError(
-        "format must be one of "
-        "['html', 'json', 'png', 'svg', 'pdf', 'vega', 'vega-lite']"
-    )
+    else:
+        msg = (
+            "format must be one of "
+            "['html', 'json', 'png', 'svg', 'pdf', 'vega', 'vega-lite']"
+        )
+        raise ValueError(msg)
 
 
 def _spec_to_mimebundle_with_engine(
     spec: dict,
     format: Literal["png", "svg", "pdf", "vega"],
     mode: Literal["vega-lite", "vega"],
-    format_locale: Optional[Union[str, dict]] = None,
-    time_format_locale: Optional[Union[str, dict]] = None,
+    format_locale: str | dict | None = None,
+    time_format_locale: str | dict | None = None,
     **kwargs,
-) -> Union[dict, Tuple[dict, dict]]:
+) -> Any:
     """Helper for Vega-Lite to mimebundle conversions that require an engine
 
     Parameters
@@ -218,17 +274,17 @@ def _spec_to_mimebundle_with_engine(
         else:
             # This should be validated above
             # but raise exception for the sake of future development
-            raise ValueError("Unexpected format {fmt!r}".format(fmt=format))
+            msg = f"Unexpected format {format!r}"
+            raise ValueError(msg)
     else:
         # This should be validated above
         # but raise exception for the sake of future development
-        raise ValueError(
-            "Unexpected normalized_engine {eng!r}".format(eng=normalized_engine)
-        )
+        msg = f"Unexpected normalized_engine {normalized_engine!r}"
+        raise ValueError(msg)
 
 
 def _validate_normalize_engine(
-    engine: Optional[Literal["vl-convert"]],
+    engine: Literal["vl-convert"] | None,
     format: Literal["png", "svg", "pdf", "vega"],
 ) -> str:
     """Helper to validate and normalize the user-provided engine
@@ -252,25 +308,20 @@ def _validate_normalize_engine(
     # Validate or infer default value of normalized_engine
     if normalized_engine == "vlconvert":
         if vlc is None:
-            raise ValueError(
-                "The 'vl-convert' conversion engine requires the vl-convert-python package"
-            )
+            msg = "The 'vl-convert' conversion engine requires the vl-convert-python package"
+            raise ValueError(msg)
     elif normalized_engine is None:
         if vlc is not None:
             normalized_engine = "vlconvert"
         else:
-            raise ValueError(
-                "Saving charts in {fmt!r} format requires the vl-convert-python package: "
-                "see https://altair-viz.github.io/user_guide/saving_charts.html#png-svg-and-pdf-format".format(
-                    fmt=format
-                )
+            msg = (
+                f"Saving charts in {format!r} format requires the vl-convert-python package: "
+                "see https://altair-viz.github.io/user_guide/saving_charts.html#png-svg-and-pdf-format"
             )
+            raise ValueError(msg)
     else:
-        raise ValueError(
-            "Invalid conversion engine {engine!r}. Expected vl-convert".format(
-                engine=engine
-            )
-        )
+        msg = f"Invalid conversion engine {engine!r}. Expected vl-convert"
+        raise ValueError(msg)
     return normalized_engine
 
 
diff --git a/altair/utils/plugin_registry.py b/altair/utils/plugin_registry.py
index b1cce92ec..53853f174 100644
--- a/altair/utils/plugin_registry.py
+++ b/altair/utils/plugin_registry.py
@@ -1,8 +1,13 @@
+from __future__ import annotations
+
 from functools import partial
-from typing import Any, Dict, List, Optional, Generic, TypeVar, Union, cast, Callable
-from types import TracebackType
+from typing import Any, Generic, TypeVar, cast, Callable, TYPE_CHECKING
+
 from importlib.metadata import entry_points
 
+if TYPE_CHECKING:
+    from types import TracebackType
+
 
 PluginType = TypeVar("PluginType")
 
@@ -27,21 +32,21 @@ class PluginEnabler:
         # plugins back to original state
     """
 
-    def __init__(self, registry: "PluginRegistry", name: str, **options):
-        self.registry = registry  # type: PluginRegistry
-        self.name = name  # type: str
-        self.options = options  # type: Dict[str, Any]
-        self.original_state = registry._get_state()  # type: Dict[str, Any]
+    def __init__(self, registry: PluginRegistry, name: str, **options):
+        self.registry: PluginRegistry = registry
+        self.name: str = name
+        self.options: dict[str, Any] = options
+        self.original_state: dict[str, Any] = registry._get_state()
         self.registry._enable(name, **options)
 
-    def __enter__(self) -> "PluginEnabler":
+    def __enter__(self) -> PluginEnabler:
         return self
 
     def __exit__(self, typ: type, value: Exception, traceback: TracebackType) -> None:
         self.registry._set_state(self.original_state)
 
     def __repr__(self) -> str:
-        return "{}.enable({!r})".format(self.registry.__class__.__name__, self.name)
+        return f"{self.registry.__class__.__name__}.enable({self.name!r})"
 
 
 class PluginRegistry(Generic[PluginType]):
@@ -63,11 +68,11 @@ class PluginRegistry(Generic[PluginType]):
 
     # this is a mapping of name to error message to allow custom error messages
     # in case an entrypoint is not found
-    entrypoint_err_messages = {}  # type: Dict[str, str]
+    entrypoint_err_messages: dict[str, str] = {}
 
     # global settings is a key-value mapping of settings that are stored globally
     # in the registry rather than passed to the plugins
-    _global_settings = {}  # type: Dict[str, Any]
+    _global_settings: dict[str, Any] = {}
 
     def __init__(self, entry_point_group: str = "", plugin_type: type = Callable):  # type: ignore[assignment]
         """Create a PluginRegistry for a named entry point group.
@@ -80,17 +85,15 @@ def __init__(self, entry_point_group: str = "", plugin_type: type = Callable):
             A type that will optionally be used for runtime type checking of
             loaded plugins using isinstance.
         """
-        self.entry_point_group = entry_point_group  # type: str
-        self.plugin_type = plugin_type  # type: Optional[type]
-        self._active = None  # type: Optional[PluginType]
-        self._active_name = ""  # type: str
-        self._plugins = {}  # type: Dict[str, PluginType]
-        self._options = {}  # type: Dict[str, Any]
-        self._global_settings = self.__class__._global_settings.copy()  # type: dict
-
-    def register(
-        self, name: str, value: Union[Optional[PluginType], Any]
-    ) -> Optional[PluginType]:
+        self.entry_point_group: str = entry_point_group
+        self.plugin_type: type[Any] = plugin_type
+        self._active: PluginType | None = None
+        self._active_name: str = ""
+        self._plugins: dict[str, PluginType] = {}
+        self._options: dict[str, Any] = {}
+        self._global_settings: dict[str, Any] = self.__class__._global_settings.copy()
+
+    def register(self, name: str, value: PluginType | Any | None) -> PluginType | None:
         """Register a plugin by name and value.
 
         This method is used for explicit registration of a plugin and shouldn't be
@@ -111,11 +114,13 @@ def register(
         if value is None:
             return self._plugins.pop(name, None)
         else:
-            assert isinstance(value, self.plugin_type)  # type: ignore[arg-type]  # Should ideally be fixed by better annotating plugin_type
+            assert isinstance(
+                value, self.plugin_type
+            )  # Should ideally be fixed by better annotating plugin_type
             self._plugins[name] = value
             return value
 
-    def names(self) -> List[str]:
+    def names(self) -> list[str]:
         """List the names of the registered and entry points plugins."""
         exts = list(self._plugins.keys())
         e_points = importlib_metadata_get(self.entry_point_group)
@@ -123,7 +128,7 @@ def names(self) -> List[str]:
         exts.extend(more_exts)
         return sorted(set(exts))
 
-    def _get_state(self) -> Dict[str, Any]:
+    def _get_state(self) -> dict[str, Any]:
         """Return a dictionary representing the current state of the registry"""
         return {
             "_active": self._active,
@@ -133,7 +138,7 @@ def _get_state(self) -> Dict[str, Any]:
             "_global_settings": self._global_settings.copy(),
         }
 
-    def _set_state(self, state: Dict[str, Any]) -> None:
+    def _set_state(self, state: dict[str, Any]) -> None:
         """Reset the state of the registry"""
         assert set(state.keys()) == {
             "_active",
@@ -148,11 +153,11 @@ def _set_state(self, state: Dict[str, Any]) -> None:
     def _enable(self, name: str, **options) -> None:
         if name not in self._plugins:
             try:
-                (ep,) = [
+                (ep,) = (
                     ep
                     for ep in importlib_metadata_get(self.entry_point_group)
                     if ep.name == name
-                ]
+                )
             except ValueError as err:
                 if name in self.entrypoint_err_messages:
                     raise ValueError(self.entrypoint_err_messages[name]) from err
@@ -166,7 +171,7 @@ def _enable(self, name: str, **options) -> None:
             self._global_settings[key] = options.pop(key)
         self._options = options
 
-    def enable(self, name: Optional[str] = None, **options) -> PluginEnabler:
+    def enable(self, name: str | None = None, **options) -> PluginEnabler:
         """Enable a plugin by name.
 
         This can be either called directly, or used as a context manager.
@@ -195,11 +200,11 @@ def active(self) -> str:
         return self._active_name
 
     @property
-    def options(self) -> Dict[str, Any]:
+    def options(self) -> dict[str, Any]:
         """Return the current options dictionary"""
         return self._options
 
-    def get(self) -> Optional[Union[PluginType, Callable[..., Any]]]:
+    def get(self) -> PluginType | Callable[..., Any] | None:
         """Return the currently active plugin."""
         if self._options:
             if func := self._active:
@@ -207,14 +212,13 @@ def get(self) -> Optional[Union[PluginType, Callable[..., Any]]]:
                 # error: Argument 1 to "partial" has incompatible type "PluginType"; expected "Callable[..., Never]"
                 return partial(func, **self._options)  # type: ignore[arg-type]
             else:
-                raise TypeError("Unclear what this meant by passing to curry.")
+                msg = "Unclear what this meant by passing to curry."
+                raise TypeError(msg)
         else:
             return self._active
 
     def __repr__(self) -> str:
-        return "{}(active={!r}, registered={!r})" "".format(
-            self.__class__.__name__, self._active_name, list(self.names())
-        )
+        return f"{type(self).__name__}(active={self.active!r}, registered={self.names()!r})"
 
 
 def importlib_metadata_get(group):
diff --git a/altair/utils/save.py b/altair/utils/save.py
index 609486bc6..3a8816e17 100644
--- a/altair/utils/save.py
+++ b/altair/utils/save.py
@@ -1,41 +1,46 @@
+from __future__ import annotations
 import json
 import pathlib
 import warnings
-from typing import IO, Union, Optional, Literal
+from typing import IO, Any, Literal, TYPE_CHECKING
 
 from .mimebundle import spec_to_mimebundle
 from ..vegalite.v5.data import data_transformers
 from altair.utils._vegafusion_data import using_vegafusion
 from altair.utils.deprecation import AltairDeprecationWarning
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 
 def write_file_or_filename(
-    fp: Union[str, pathlib.Path, IO],
-    content: Union[str, bytes],
+    fp: str | Path | IO,
+    content: str | bytes,
     mode: str = "w",
-    encoding: Optional[str] = None,
+    encoding: str | None = None,
 ) -> None:
     """Write content to fp, whether fp is a string, a pathlib Path or a
     file-like object"""
     if isinstance(fp, (str, pathlib.Path)):
-        with open(file=fp, mode=mode, encoding=encoding) as f:
+        with pathlib.Path(fp).open(mode=mode, encoding=encoding) as f:
             f.write(content)
     else:
         fp.write(content)
 
 
 def set_inspect_format_argument(
-    format: Optional[str], fp: Union[str, pathlib.Path, IO], inline: bool
+    format: str | None, fp: str | Path | IO, inline: bool
 ) -> str:
     """Inspect the format argument in the save function"""
     if format is None:
         if isinstance(fp, (str, pathlib.Path)):
             format = pathlib.Path(fp).suffix.lstrip(".")
         else:
-            raise ValueError(
+            msg = (
                 "must specify file format: "
                 "['png', 'svg', 'pdf', 'html', 'json', 'vega']"
             )
+            raise ValueError(msg)
 
     if format != "html" and inline:
         warnings.warn("inline argument ignored for non HTML formats.", stacklevel=1)
@@ -44,10 +49,10 @@ def set_inspect_format_argument(
 
 
 def set_inspect_mode_argument(
-    mode: Optional[Literal["vega-lite"]],
-    embed_options: dict,
-    spec: dict,
-    vegalite_version: Optional[str],
+    mode: Literal["vega-lite"] | None,
+    embed_options: dict[str, Any],
+    spec: dict[str, Any],
+    vegalite_version: str | None,
 ) -> Literal["vega-lite"]:
     """Inspect the mode argument in the save function"""
     if mode is None:
@@ -59,27 +64,29 @@ def set_inspect_mode_argument(
             mode = "vega-lite"
 
     if mode != "vega-lite":
-        raise ValueError("mode must be 'vega-lite', " "not '{}'".format(mode))
+        msg = "mode must be 'vega-lite', " f"not '{mode}'"
+        raise ValueError(msg)
 
     if mode == "vega-lite" and vegalite_version is None:
-        raise ValueError("must specify vega-lite version")
+        msg = "must specify vega-lite version"
+        raise ValueError(msg)
 
     return mode
 
 
 def save(
     chart,
-    fp: Union[str, pathlib.Path, IO],
-    vega_version: Optional[str],
-    vegaembed_version: Optional[str],
-    format: Optional[Literal["json", "html", "png", "svg", "pdf"]] = None,
-    mode: Optional[Literal["vega-lite"]] = None,
-    vegalite_version: Optional[str] = None,
-    embed_options: Optional[dict] = None,
-    json_kwds: Optional[dict] = None,
-    webdriver: Optional[Literal["chrome", "firefox"]] = None,
+    fp: str | Path | IO,
+    vega_version: str | None,
+    vegaembed_version: str | None,
+    format: Literal["json", "html", "png", "svg", "pdf"] | None = None,
+    mode: Literal["vega-lite"] | None = None,
+    vegalite_version: str | None = None,
+    embed_options: dict | None = None,
+    json_kwds: dict | None = None,
+    webdriver: Literal["chrome", "firefox"] | None = None,
     scale_factor: float = 1,
-    engine: Optional[Literal["vl-convert"]] = None,
+    engine: Literal["vl-convert"] | None = None,
     inline: bool = False,
     **kwargs,
 ) -> None:
@@ -141,7 +148,7 @@ def save(
     encoding = kwargs.get("encoding", "utf-8")
     format = set_inspect_format_argument(format, fp, inline)  # type: ignore[assignment]
 
-    def perform_save():
+    def perform_save() -> None:
         spec = chart.to_dict(context={"pre_transform": False})
 
         inner_mode = set_inspect_mode_argument(
@@ -154,7 +161,7 @@ def perform_save():
         elif format == "html":
             if inline:
                 kwargs["template"] = "inline"
-            mimebundle = spec_to_mimebundle(
+            mb_html = spec_to_mimebundle(
                 spec=spec,
                 format=format,
                 mode=inner_mode,
@@ -166,10 +173,24 @@ def perform_save():
                 **kwargs,
             )
             write_file_or_filename(
-                fp, mimebundle["text/html"], mode="w", encoding=encoding
+                fp, mb_html["text/html"], mode="w", encoding=encoding
+            )
+        elif format == "png":
+            mb_png = spec_to_mimebundle(
+                spec=spec,
+                format=format,
+                mode=inner_mode,
+                vega_version=vega_version,
+                vegalite_version=vegalite_version,
+                vegaembed_version=vegaembed_version,
+                embed_options=embed_options,
+                scale_factor=scale_factor,
+                engine=engine,
+                **kwargs,
             )
-        elif format in ["png", "svg", "pdf", "vega"]:
-            mimebundle = spec_to_mimebundle(
+            write_file_or_filename(fp, mb_png[0]["image/png"], mode="wb")
+        elif format in {"svg", "pdf", "vega"}:
+            mb_any = spec_to_mimebundle(
                 spec=spec,
                 format=format,
                 mode=inner_mode,
@@ -181,16 +202,15 @@ def perform_save():
                 engine=engine,
                 **kwargs,
             )
-            if format == "png":
-                write_file_or_filename(fp, mimebundle[0]["image/png"], mode="wb")
-            elif format == "pdf":
-                write_file_or_filename(fp, mimebundle["application/pdf"], mode="wb")
+            if format == "pdf":
+                write_file_or_filename(fp, mb_any["application/pdf"], mode="wb")
             else:
                 write_file_or_filename(
-                    fp, mimebundle["image/svg+xml"], mode="w", encoding=encoding
+                    fp, mb_any["image/svg+xml"], mode="w", encoding=encoding
                 )
         else:
-            raise ValueError("Unsupported format: '{}'".format(format))
+            msg = f"Unsupported format: '{format}'"
+            raise ValueError(msg)
 
     if using_vegafusion():
         # When the vegafusion data transformer is enabled, transforms will be
diff --git a/altair/utils/schemapi.py b/altair/utils/schemapi.py
index 10b2597e6..822526b2f 100644
--- a/altair/utils/schemapi.py
+++ b/altair/utils/schemapi.py
@@ -1,32 +1,31 @@
 # The contents of this file are automatically written by
 # tools/generate_schema_wrapper.py. Do not modify directly.
-import collections
+from __future__ import annotations
+
 import contextlib
 import copy
 import inspect
 import json
-import sys
 import textwrap
+from collections import defaultdict
+from importlib.metadata import version as importlib_version
+from itertools import chain, zip_longest
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Sequence,
-    List,
-    Dict,
-    Optional,
-    DefaultDict,
-    Tuple,
+    Final,
     Iterable,
-    Type,
-    Generator,
-    Union,
-    overload,
+    Iterator,
     Literal,
+    Sequence,
     TypeVar,
+    Union,
+    overload,
+    List,
+    Dict,
 )
-from itertools import zip_longest
-from importlib.metadata import version as importlib_version
-from typing import Final
-
+from typing_extensions import TypeAlias
+from functools import partial
 import jsonschema
 import jsonschema.exceptions
 import jsonschema.validators
@@ -39,15 +38,27 @@
 # not yet be fully instantiated in case your code is being executed during import time
 from altair import vegalite
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+if TYPE_CHECKING:
+    import sys
+
+    from referencing import Registry
 
-TSchemaBase = TypeVar("TSchemaBase", bound=Type["SchemaBase"])
+    from altair import ChartType
+    from typing import ClassVar
+
+    if sys.version_info >= (3, 13):
+        from typing import TypeIs
+    else:
+        from typing_extensions import TypeIs
+
+    if sys.version_info >= (3, 11):
+        from typing import Self, Never
+    else:
+        from typing_extensions import Self, Never
 
-ValidationErrorList = List[jsonschema.exceptions.ValidationError]
-GroupedValidationErrors = Dict[str, ValidationErrorList]
+
+ValidationErrorList: TypeAlias = List[jsonschema.exceptions.ValidationError]
+GroupedValidationErrors: TypeAlias = Dict[str, ValidationErrorList]
 
 # This URI is arbitrary and could be anything else. It just cannot be an empty
 # string as we need to reference the schema registered in
@@ -85,7 +96,7 @@ def disable_debug_mode() -> None:
 
 
 @contextlib.contextmanager
-def debug_mode(arg: bool) -> Generator[None, None, None]:
+def debug_mode(arg: bool) -> Iterator[None]:
     global DEBUG_MODE
     original = DEBUG_MODE
     DEBUG_MODE = arg
@@ -97,9 +108,9 @@ def debug_mode(arg: bool) -> Generator[None, None, None]:
 
 @overload
 def validate_jsonschema(
-    spec: Dict[str, Any],
-    schema: Dict[str, Any],
-    rootschema: Optional[Dict[str, Any]] = ...,
+    spec: Any,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = ...,
     *,
     raise_error: Literal[True] = ...,
 ) -> None: ...
@@ -107,12 +118,12 @@ def validate_jsonschema(
 
 @overload
 def validate_jsonschema(
-    spec: Dict[str, Any],
-    schema: Dict[str, Any],
-    rootschema: Optional[Dict[str, Any]] = ...,
+    spec: Any,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = ...,
     *,
     raise_error: Literal[False],
-) -> Optional[jsonschema.exceptions.ValidationError]: ...
+) -> jsonschema.exceptions.ValidationError | None: ...
 
 
 def validate_jsonschema(
@@ -136,7 +147,7 @@ def validate_jsonschema(
 
         # Nothing special about this first error but we need to choose one
         # which can be raised
-        main_error = list(grouped_errors.values())[0][0]
+        main_error = next(iter(grouped_errors.values()))[0]
         # All errors are then attached as a new attribute to ValidationError so that
         # they can be used in SchemaValidationError to craft a more helpful
         # error message. Setting a new attribute like this is not ideal as
@@ -152,9 +163,9 @@ def validate_jsonschema(
 
 
 def _get_errors_from_spec(
-    spec: Dict[str, Any],
-    schema: Dict[str, Any],
-    rootschema: Optional[Dict[str, Any]] = None,
+    spec: dict[str, Any],
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = None,
 ) -> ValidationErrorList:
     """Uses the relevant jsonschema validator to validate the passed in spec
     against the schema using the rootschema to resolve references.
@@ -175,7 +186,7 @@ def _get_errors_from_spec(
     validator_cls = jsonschema.validators.validator_for(
         {"$schema": json_schema_draft_url}
     )
-    validator_kwargs: Dict[str, Any] = {}
+    validator_kwargs: dict[str, Any] = {}
     if hasattr(validator_cls, "FORMAT_CHECKER"):
         validator_kwargs["format_checker"] = validator_cls.FORMAT_CHECKER
 
@@ -198,7 +209,7 @@ def _get_errors_from_spec(
     return errors
 
 
-def _get_json_schema_draft_url(schema: dict) -> str:
+def _get_json_schema_draft_url(schema: dict[str, Any]) -> str:
     return schema.get("$schema", _DEFAULT_JSON_SCHEMA_DRAFT_URL)
 
 
@@ -208,32 +219,34 @@ def _use_referencing_library() -> bool:
     return Version(jsonschema_version_str) >= Version("4.18")
 
 
-def _prepare_references_in_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+def _prepare_references_in_schema(schema: dict[str, Any]) -> dict[str, Any]:
     # Create a copy so that $ref is not modified in the original schema in case
     # that it would still reference a dictionary which might be attached to
     # an Altair class _schema attribute
     schema = copy.deepcopy(schema)
 
-    def _prepare_refs(d: Dict[str, Any]) -> Dict[str, Any]:
-        """Add _VEGA_LITE_ROOT_URI in front of all $ref values. This function
-        recursively iterates through the whole dictionary."""
+    def _prepare_refs(d: dict[str, Any]) -> dict[str, Any]:
+        """Add _VEGA_LITE_ROOT_URI in front of all $ref values.
+
+        This function recursively iterates through the whole dictionary.
+
+        $ref values can only be nested in dictionaries or lists
+        as the passed in `d` dictionary comes from the Vega-Lite json schema
+        and in json we only have arrays (-> lists in Python) and objects
+        (-> dictionaries in Python) which we need to iterate through.
+        """
         for key, value in d.items():
             if key == "$ref":
                 d[key] = _VEGA_LITE_ROOT_URI + d[key]
-            else:
-                # $ref values can only be nested in dictionaries or lists
-                # as the passed in `d` dictionary comes from the Vega-Lite json schema
-                # and in json we only have arrays (-> lists in Python) and objects
-                # (-> dictionaries in Python) which we need to iterate through.
-                if isinstance(value, dict):
-                    d[key] = _prepare_refs(value)
-                elif isinstance(value, list):
-                    prepared_values = []
-                    for v in value:
-                        if isinstance(v, dict):
-                            v = _prepare_refs(v)
-                        prepared_values.append(v)
-                    d[key] = prepared_values
+            elif isinstance(value, dict):
+                d[key] = _prepare_refs(value)
+            elif isinstance(value, list):
+                prepared_values = []
+                for v in value:
+                    if isinstance(v, dict):
+                        v = _prepare_refs(v)
+                    prepared_values.append(v)
+                d[key] = prepared_values
         return d
 
     schema = _prepare_refs(schema)
@@ -243,8 +256,8 @@ def _prepare_refs(d: Dict[str, Any]) -> Dict[str, Any]:
 # We do not annotate the return value here as the referencing library is not always
 # available and this function is only executed in those cases.
 def _get_referencing_registry(
-    rootschema: Dict[str, Any], json_schema_draft_url: Optional[str] = None
-):
+    rootschema: dict[str, Any], json_schema_draft_url: str | None = None
+) -> Registry:
     # Referencing is a dependency of newer jsonschema versions, starting with the
     # version that is specified in _use_referencing_library and we therefore
     # can expect that it is installed if the function returns True.
@@ -288,7 +301,7 @@ def _group_errors_by_json_path(
     a chart specification and can therefore be considered as an identifier of an
     'issue' in the chart that needs to be fixed.
     """
-    errors_by_json_path = collections.defaultdict(list)
+    errors_by_json_path = defaultdict(list)
     for err in errors:
         err_key = getattr(err, "json_path", _json_path(err))
         errors_by_json_path[err_key].append(err)
@@ -356,7 +369,7 @@ def _deduplicate_errors(
         }
         deduplicated_errors: ValidationErrorList = []
         for validator, errors in errors_by_validator.items():
-            deduplication_func = deduplication_functions.get(validator, None)
+            deduplication_func = deduplication_functions.get(validator)
             if deduplication_func is not None:
                 errors = deduplication_func(errors)
             deduplicated_errors.extend(_deduplicate_by_message(errors))
@@ -387,9 +400,7 @@ def _group_errors_by_validator(errors: ValidationErrorList) -> GroupedValidation
     was set although no additional properties are allowed then "validator" is
     `"additionalProperties`, etc.
     """
-    errors_by_validator: DefaultDict[str, ValidationErrorList] = (
-        collections.defaultdict(list)
-    )
+    errors_by_validator: defaultdict[str, ValidationErrorList] = defaultdict(list)
     for err in errors:
         # Ignore mypy error as err.validator as it wrongly sees err.validator
         # as of type Optional[Validator] instead of str which it is according
@@ -455,7 +466,7 @@ def _deduplicate_by_message(errors: ValidationErrorList) -> ValidationErrorList:
     return list({e.message: e for e in errors}.values())
 
 
-def _subclasses(cls: type) -> Generator[type, None, None]:
+def _subclasses(cls: type[Any]) -> Iterator[type[Any]]:
     """Breadth-first sequence of all classes which inherit from cls."""
     seen = set()
     current_set = {cls}
@@ -466,7 +477,7 @@ def _subclasses(cls: type) -> Generator[type, None, None]:
             yield cls
 
 
-def _todict(obj: Any, context: Optional[Dict[str, Any]]) -> Any:
+def _todict(obj: Any, context: dict[str, Any] | None) -> Any:
     """Convert an object to a dict representation."""
     if isinstance(obj, SchemaBase):
         return obj.to_dict(validate=False, context=context)
@@ -485,8 +496,8 @@ def _todict(obj: Any, context: Optional[Dict[str, Any]]) -> Any:
 
 
 def _resolve_references(
-    schema: Dict[str, Any], rootschema: Optional[Dict[str, Any]] = None
-) -> Dict[str, Any]:
+    schema: dict[str, Any], rootschema: dict[str, Any] | None = None
+) -> dict[str, Any]:
     """Resolve schema references until there is no $ref anymore
     in the top-level of the dictionary.
     """
@@ -511,7 +522,7 @@ def _resolve_references(
 class SchemaValidationError(jsonschema.ValidationError):
     """A wrapper for jsonschema.ValidationError with friendlier traceback"""
 
-    def __init__(self, obj: "SchemaBase", err: jsonschema.ValidationError) -> None:
+    def __init__(self, obj: SchemaBase, err: jsonschema.ValidationError) -> None:
         super().__init__(**err._contents())
         self.obj = obj
         self._errors: GroupedValidationErrors = getattr(
@@ -526,14 +537,14 @@ def __str__(self) -> str:
 
     def _get_message(self) -> str:
         def indent_second_line_onwards(message: str, indent: int = 4) -> str:
-            modified_lines: List[str] = []
+            modified_lines: list[str] = []
             for idx, line in enumerate(message.split("\n")):
                 if idx > 0 and len(line) > 0:
                     line = " " * indent + line
                 modified_lines.append(line)
             return "\n".join(modified_lines)
 
-        error_messages: List[str] = []
+        error_messages: list[str] = []
         # Only show a maximum of 3 errors as else the final message returned by this
         # method could get very long.
         for errors in list(self._errors.values())[:3]:
@@ -588,7 +599,7 @@ def _get_additional_properties_error_message(
 
     def _get_altair_class_for_error(
         self, error: jsonschema.exceptions.ValidationError
-    ) -> Type["SchemaBase"]:
+    ) -> type[SchemaBase]:
         """Try to get the lowest class possible in the chart hierarchy so
         it can be displayed in the error message. This should lead to more informative
         error messages pointing the user closer to the source of the issue.
@@ -610,13 +621,13 @@ def _get_altair_class_for_error(
     @staticmethod
     def _format_params_as_table(param_dict_keys: Iterable[str]) -> str:
         """Format param names into a table so that they are easier to read"""
-        param_names: Tuple[str, ...]
-        name_lengths: Tuple[int, ...]
+        param_names: tuple[str, ...]
+        name_lengths: tuple[int, ...]
         param_names, name_lengths = zip(
             *[
                 (name, len(name))
                 for name in param_dict_keys
-                if name not in ["kwds", "self"]
+                if name not in {"kwds", "self"}
             ]
         )
         # Worst case scenario with the same longest param name in the same
@@ -629,24 +640,24 @@ def _format_params_as_table(param_dict_keys: Iterable[str]) -> str:
         columns = min(max_column_width // max_name_length, square_columns)
 
         # Compute roughly equal column heights to evenly divide the param names
-        def split_into_equal_parts(n: int, p: int) -> List[int]:
+        def split_into_equal_parts(n: int, p: int) -> list[int]:
             return [n // p + 1] * (n % p) + [n // p] * (p - n % p)
 
         column_heights = split_into_equal_parts(num_param_names, columns)
 
         # Section the param names into columns and compute their widths
-        param_names_columns: List[Tuple[str, ...]] = []
-        column_max_widths: List[int] = []
+        param_names_columns: list[tuple[str, ...]] = []
+        column_max_widths: list[int] = []
         last_end_idx: int = 0
         for ch in column_heights:
             param_names_columns.append(param_names[last_end_idx : last_end_idx + ch])
             column_max_widths.append(
-                max([len(param_name) for param_name in param_names_columns[-1]])
+                max(len(param_name) for param_name in param_names_columns[-1])
             )
             last_end_idx = ch + last_end_idx
 
         # Transpose the param name columns into rows to facilitate looping
-        param_names_rows: List[Tuple[str, ...]] = []
+        param_names_rows: list[tuple[str, ...]] = []
         for li in zip_longest(*param_names_columns, fillvalue=""):
             param_names_rows.append(li)
         # Build the table as a string by iterating over and formatting the rows
@@ -668,7 +679,7 @@ def _get_default_error_message(
         self,
         errors: ValidationErrorList,
     ) -> str:
-        bullet_points: List[str] = []
+        bullet_points: list[str] = []
         errors_by_validator = _group_errors_by_validator(errors)
         if "enum" in errors_by_validator:
             for error in errors_by_validator["enum"]:
@@ -712,7 +723,7 @@ def _get_default_error_message(
         # considered so far. This is not expected to be used but more exists
         # as a fallback for cases which were not known during development.
         for validator, errors in errors_by_validator.items():
-            if validator not in ("enum", "type"):
+            if validator not in {"enum", "type"}:
                 message += "\n".join([e.message for e in errors])
 
         return message
@@ -723,16 +734,28 @@ class UndefinedType:
 
     __instance = None
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args, **kwargs) -> Self:
         if not isinstance(cls.__instance, cls):
             cls.__instance = object.__new__(cls, *args, **kwargs)
         return cls.__instance
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Undefined"
 
 
 Undefined = UndefinedType()
+T = TypeVar("T")
+Optional: TypeAlias = Union[T, UndefinedType]
+"""One of the sepcified types, or the `Undefined` singleton.
+
+
+Examples
+--------
+```py
+MaybeDictOrStr: TypeAlias = Optional[dict[str, Any] | str]
+LongerDictOrStr: TypeAlias = dict[str, Any] | str | UndefinedType
+```
+"""
 
 
 class SchemaBase:
@@ -742,9 +765,9 @@ class SchemaBase:
     the _rootschema class attribute) which is used for validation.
     """
 
-    _schema: Optional[Dict[str, Any]] = None
-    _rootschema: Optional[Dict[str, Any]] = None
-    _class_is_valid_at_instantiation: bool = True
+    _schema: ClassVar[dict[str, Any] | Any] = None
+    _rootschema: ClassVar[dict[str, Any] | None] = None
+    _class_is_valid_at_instantiation: ClassVar[bool] = True
 
     def __init__(self, *args: Any, **kwds: Any) -> None:
         # Two valid options for initialization, which should be handled by
@@ -752,16 +775,17 @@ def __init__(self, *args: Any, **kwds: Any) -> None:
         # - a single arg with no kwds, for, e.g. {'type': 'string'}
         # - zero args with zero or more kwds for {'type': 'object'}
         if self._schema is None:
-            raise ValueError(
-                "Cannot instantiate object of type {}: "
+            msg = (
+                f"Cannot instantiate object of type {self.__class__}: "
                 "_schema class attribute is not defined."
-                "".format(self.__class__)
+                ""
             )
+            raise ValueError(msg)
 
         if kwds:
             assert len(args) == 0
         else:
-            assert len(args) in [0, 1]
+            assert len(args) in {0, 1}
 
         # use object.__setattr__ because we override setattr below.
         object.__setattr__(self, "_args", args)
@@ -771,7 +795,7 @@ def __init__(self, *args: Any, **kwds: Any) -> None:
             self.to_dict(validate=True)
 
     def copy(
-        self, deep: Union[bool, Iterable] = True, ignore: Optional[list] = None
+        self, deep: bool | Iterable[Any] = True, ignore: list[str] | None = None
     ) -> Self:
         """Return a copy of the object
 
@@ -797,7 +821,7 @@ def _shallow_copy(obj):
             else:
                 return obj
 
-        def _deep_copy(obj, ignore: Optional[list] = None):
+        def _deep_copy(obj, ignore: list[str] | None = None):
             if ignore is None:
                 ignore = []
             if isinstance(obj, SchemaBase):
@@ -852,35 +876,35 @@ def __getattr__(self, attr):
             return self._kwds[attr]
         else:
             try:
-                _getattr = super(SchemaBase, self).__getattr__
+                _getattr = super().__getattr__
             except AttributeError:
-                _getattr = super(SchemaBase, self).__getattribute__
+                _getattr = super().__getattribute__
             return _getattr(attr)
 
-    def __setattr__(self, item, val):
+    def __setattr__(self, item, val) -> None:
         self._kwds[item] = val
 
     def __getitem__(self, item):
         return self._kwds[item]
 
-    def __setitem__(self, item, val):
+    def __setitem__(self, item, val) -> None:
         self._kwds[item] = val
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self._kwds:
-            args = (
-                "{}: {!r}".format(key, val)
+            it = (
+                f"{key}: {val!r}"
                 for key, val in sorted(self._kwds.items())
                 if val is not Undefined
             )
-            args = "\n" + ",\n".join(args)
-            return "{0}({{{1}\n}})".format(
+            args = "\n" + ",\n".join(it)
+            return "{}({{{}\n}})".format(
                 self.__class__.__name__, args.replace("\n", "\n  ")
             )
         else:
-            return "{}({!r})".format(self.__class__.__name__, self._args[0])
+            return f"{self.__class__.__name__}({self._args[0]!r})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return (
             type(self) is type(other)
             and self._args == other._args
@@ -891,9 +915,9 @@ def to_dict(
         self,
         validate: bool = True,
         *,
-        ignore: Optional[List[str]] = None,
-        context: Optional[Dict[str, Any]] = None,
-    ) -> dict:
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Return a dictionary representation of the object
 
         Parameters
@@ -941,7 +965,7 @@ def to_dict(
             # when a non-ordinal data type is specifed manually
             # or if the encoding channel does not support sorting
             if "sort" in parsed_shorthand and (
-                "sort" not in kwds or kwds["type"] not in ["ordinal", Undefined]
+                "sort" not in kwds or kwds["type"] not in {"ordinal", Undefined}
             ):
                 parsed_shorthand.pop("sort")
 
@@ -953,7 +977,7 @@ def to_dict(
                 }
             )
             kwds = {
-                k: v for k, v in kwds.items() if k not in list(ignore) + ["shorthand"]
+                k: v for k, v in kwds.items() if k not in {*list(ignore), "shorthand"}
             }
             if "mark" in kwds and isinstance(kwds["mark"], str):
                 kwds["mark"] = {"type": kwds["mark"]}
@@ -962,10 +986,11 @@ def to_dict(
                 context=context,
             )
         else:
-            raise ValueError(
-                "{} instance has both a value and properties : "
-                "cannot serialize to dict".format(self.__class__)
+            msg = (
+                f"{self.__class__} instance has both a value and properties : "
+                "cannot serialize to dict"
             )
+            raise ValueError(msg)
         if validate:
             try:
                 self.validate(result)
@@ -981,11 +1006,11 @@ def to_dict(
     def to_json(
         self,
         validate: bool = True,
-        indent: Optional[Union[int, str]] = 2,
+        indent: int | str | None = 2,
         sort_keys: bool = True,
         *,
-        ignore: Optional[List[str]] = None,
-        context: Optional[Dict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
         **kwargs,
     ) -> str:
         """Emit the JSON representation for this object as a string.
@@ -1026,19 +1051,17 @@ def to_json(
         return json.dumps(dct, indent=indent, sort_keys=sort_keys, **kwargs)
 
     @classmethod
-    def _default_wrapper_classes(cls) -> Generator[Type["SchemaBase"], None, None]:
+    def _default_wrapper_classes(cls) -> Iterator[type[SchemaBase]]:
         """Return the set of classes used within cls.from_dict()"""
         return _subclasses(SchemaBase)
 
     @classmethod
     def from_dict(
-        cls,
-        dct: dict,
+        cls: type[TSchemaBase],
+        dct: dict[str, Any],
         validate: bool = True,
-        _wrapper_classes: Optional[Iterable[Type["SchemaBase"]]] = None,
-        # Type hints for this method would get rather complicated
-        # if we want to provide a more specific return type
-    ) -> "SchemaBase":
+        _wrapper_classes: Iterable[type[SchemaBase]] | None = None,
+    ) -> TSchemaBase:
         """Construct class from a dictionary representation
 
         Parameters
@@ -1077,7 +1100,7 @@ def from_json(
         **kwargs: Any,
         # Type hints for this method would get rather complicated
         # if we want to provide a more specific return type
-    ) -> Any:
+    ) -> ChartType:
         """Instantiate the object from a valid JSON string
 
         Parameters
@@ -1094,12 +1117,12 @@ def from_json(
         chart : Chart object
             The altair Chart object built from the specification.
         """
-        dct = json.loads(json_string, **kwargs)
-        return cls.from_dict(dct, validate=validate)
+        dct: dict[str, Any] = json.loads(json_string, **kwargs)
+        return cls.from_dict(dct, validate=validate)  # type: ignore[return-value]
 
     @classmethod
     def validate(
-        cls, instance: Dict[str, Any], schema: Optional[Dict[str, Any]] = None
+        cls, instance: dict[str, Any], schema: dict[str, Any] | None = None
     ) -> None:
         """
         Validate the instance against the class schema in the context of the
@@ -1114,7 +1137,7 @@ def validate(
         )
 
     @classmethod
-    def resolve_references(cls, schema: Optional[dict] = None) -> dict:
+    def resolve_references(cls, schema: dict[str, Any] | None = None) -> dict[str, Any]:
         """Resolve references in the context of this object's schema or root schema."""
         schema_to_pass = schema or cls._schema
         # For the benefit of mypy
@@ -1126,7 +1149,7 @@ def resolve_references(cls, schema: Optional[dict] = None) -> dict:
 
     @classmethod
     def validate_property(
-        cls, name: str, value: Any, schema: Optional[dict] = None
+        cls, name: str, value: Any, schema: dict[str, Any] | None = None
     ) -> None:
         """
         Validate a property against property schema in the context of the
@@ -1138,11 +1161,22 @@ def validate_property(
             value, props.get(name, {}), rootschema=cls._rootschema or cls._schema
         )
 
-    def __dir__(self) -> list:
-        return sorted(list(super().__dir__()) + list(self._kwds.keys()))
+    def __dir__(self) -> list[str]:
+        return sorted(chain(super().__dir__(), self._kwds))
+
+
+TSchemaBase = TypeVar("TSchemaBase", bound=SchemaBase)
+
 
+def _is_dict(obj: Any | dict[Any, Any]) -> TypeIs[dict[Any, Any]]:
+    return isinstance(obj, dict)
 
-def _passthrough(*args, **kwds):
+
+def _is_list(obj: Any | list[Any]) -> TypeIs[list[Any]]:
+    return isinstance(obj, list)
+
+
+def _passthrough(*args: Any, **kwds: Any) -> Any | dict[str, Any]:
     return args[0] if args else kwds
 
 
@@ -1151,21 +1185,21 @@ class _FromDict:
 
     The primary purpose of using this class is to be able to build a hash table
     that maps schemas to their wrapper classes. The candidate classes are
-    specified in the ``class_list`` argument to the constructor.
+    specified in the ``wrapper_classes`` positional-only argument to the constructor.
     """
 
     _hash_exclude_keys = ("definitions", "title", "description", "$schema", "id")
 
-    def __init__(self, class_list: Iterable[Type[SchemaBase]]) -> None:
+    def __init__(self, wrapper_classes: Iterable[type[SchemaBase]], /) -> None:
         # Create a mapping of a schema hash to a list of matching classes
         # This lets us quickly determine the correct class to construct
-        self.class_dict = collections.defaultdict(list)
-        for cls in class_list:
-            if cls._schema is not None:
-                self.class_dict[self.hash_schema(cls._schema)].append(cls)
+        self.class_dict: dict[int, list[type[SchemaBase]]] = defaultdict(list)
+        for tp in wrapper_classes:
+            if tp._schema is not None:
+                self.class_dict[self.hash_schema(tp._schema)].append(tp)
 
     @classmethod
-    def hash_schema(cls, schema: dict, use_json: bool = True) -> int:
+    def hash_schema(cls, schema: dict[str, Any], use_json: bool = True) -> int:
         """
         Compute a python hash for a nested dictionary which
         properly handles dicts, lists, sets, and tuples.
@@ -1200,84 +1234,111 @@ def _freeze(val):
 
             return hash(_freeze(schema))
 
+    @overload
     def from_dict(
         self,
-        dct: dict,
-        cls: Optional[Type[SchemaBase]] = None,
-        schema: Optional[dict] = None,
-        rootschema: Optional[dict] = None,
-        default_class=_passthrough,
-        # Type hints for this method would get rather complicated
-        # if we want to provide a more specific return type
-    ) -> Any:
+        dct: TSchemaBase,
+        tp: None = ...,
+        schema: None = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: None = ...,
+        schema: Any = ...,
+        rootschema: None = ...,
+        default_class: type[TSchemaBase] = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: None = ...,
+        schema: dict[str, Any] = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> SchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: type[TSchemaBase],
+        schema: None = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]],
+        tp: type[TSchemaBase],
+        schema: dict[str, Any],
+        rootschema: dict[str, Any] | None = ...,
+        default_class: Any = ...,
+    ) -> Never: ...
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]] | TSchemaBase,
+        tp: type[TSchemaBase] | None = None,
+        schema: dict[str, Any] | None = None,
+        rootschema: dict[str, Any] | None = None,
+        default_class: Any = _passthrough,
+    ) -> TSchemaBase:
         """Construct an object from a dict representation"""
-        if (schema is None) == (cls is None):
-            raise ValueError("Must provide either cls or schema, but not both.")
-        if schema is None:
-            # Can ignore type errors as  cls is not None in case schema is
-            schema = cls._schema  # type: ignore[union-attr]
-            # For the benefit of mypy
-            assert schema is not None
-            if rootschema:
-                rootschema = rootschema
-            elif cls is not None and cls._rootschema is not None:
-                rootschema = cls._rootschema
-            else:
-                rootschema = None
-        rootschema = rootschema or schema
-
+        target_tp: type[TSchemaBase]
+        current_schema: dict[str, Any]
         if isinstance(dct, SchemaBase):
-            return dct
-
-        if cls is None:
+            return dct  # type: ignore[return-value]
+        elif tp is not None:
+            current_schema = tp._schema
+            root_schema = rootschema or tp._rootschema or current_schema
+            target_tp = tp
+        elif schema is not None:
             # If there are multiple matches, we use the first one in the dict.
             # Our class dict is constructed breadth-first from top to bottom,
             # so the first class that matches is the most general match.
-            matches = self.class_dict[self.hash_schema(schema)]
-            if matches:
-                cls = matches[0]
-            else:
-                cls = default_class
-        schema = _resolve_references(schema, rootschema)
-
-        if "anyOf" in schema or "oneOf" in schema:
-            schemas = schema.get("anyOf", []) + schema.get("oneOf", [])
-            for possible_schema in schemas:
+            current_schema = schema
+            root_schema = rootschema or current_schema
+            matches = self.class_dict[self.hash_schema(current_schema)]
+            target_tp = matches[0] if matches else default_class
+        else:
+            msg = "Must provide either `tp` or `schema`, but not both."
+            raise ValueError(msg)
+
+        from_dict = partial(self.from_dict, rootschema=root_schema)
+        # Can also return a list?
+        resolved = _resolve_references(current_schema, root_schema)
+        if "anyOf" in resolved or "oneOf" in resolved:
+            schemas = resolved.get("anyOf", []) + resolved.get("oneOf", [])
+            for possible in schemas:
                 try:
-                    validate_jsonschema(dct, possible_schema, rootschema=rootschema)
+                    validate_jsonschema(dct, possible, rootschema=root_schema)
                 except jsonschema.ValidationError:
                     continue
                 else:
-                    return self.from_dict(
-                        dct,
-                        schema=possible_schema,
-                        rootschema=rootschema,
-                        default_class=cls,
-                    )
+                    return from_dict(dct, schema=possible, default_class=target_tp)
 
-        if isinstance(dct, dict):
+        if _is_dict(dct):
             # TODO: handle schemas for additionalProperties/patternProperties
-            props = schema.get("properties", {})
-            kwds = {}
-            for key, val in dct.items():
-                if key in props:
-                    val = self.from_dict(val, schema=props[key], rootschema=rootschema)
-                kwds[key] = val
-            return cls(**kwds)
-
-        elif isinstance(dct, list):
-            item_schema = schema.get("items", {})
-            dct = [
-                self.from_dict(val, schema=item_schema, rootschema=rootschema)
-                for val in dct
-            ]
-            return cls(dct)
+            props: dict[str, Any] = resolved.get("properties", {})
+            kwds = {
+                k: (from_dict(v, schema=props[k]) if k in props else v)
+                for k, v in dct.items()
+            }
+            return target_tp(**kwds)
+        elif _is_list(dct):
+            item_schema: dict[str, Any] = resolved.get("items", {})
+            return target_tp([from_dict(k, schema=item_schema) for k in dct])
         else:
-            return cls(dct)
+            # NOTE: Unsure what is valid here
+            return target_tp(dct)
 
 
 class _PropertySetter:
-    def __init__(self, prop: str, schema: dict) -> None:
+    def __init__(self, prop: str, schema: dict[str, Any]) -> None:
         self.prop = prop
         self.schema = schema
 
@@ -1317,14 +1378,14 @@ def __get__(self, obj, cls):
             pass
         return self
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any):
         obj = self.obj.copy()
         # TODO: use schema to validate
         obj[self.prop] = args[0] if args else kwargs
         return obj
 
 
-def with_property_setters(cls: TSchemaBase) -> TSchemaBase:
+def with_property_setters(cls: type[TSchemaBase]) -> type[TSchemaBase]:
     """
     Decorator to add property setters to a Schema class.
     """
diff --git a/altair/utils/selection.py b/altair/utils/selection.py
index 2e796cac0..fedf4bce0 100644
--- a/altair/utils/selection.py
+++ b/altair/utils/selection.py
@@ -1,5 +1,6 @@
+from __future__ import annotations
 from dataclasses import dataclass
-from typing import List, Dict, Any, NewType, Optional
+from typing import List, Dict, Any, NewType
 
 
 # Type representing the "{selection}_store" dataset that corresponds to a
@@ -22,11 +23,11 @@ class IndexSelection:
     """
 
     name: str
-    value: List[int]
+    value: list[int]
     store: Store
 
     @staticmethod
-    def from_vega(name: str, signal: Optional[Dict[str, dict]], store: Store):
+    def from_vega(name: str, signal: dict[str, dict] | None, store: Store):
         """
         Construct an IndexSelection from the raw Vega signal and dataset values.
 
@@ -67,11 +68,11 @@ class PointSelection:
     """
 
     name: str
-    value: List[Dict[str, Any]]
+    value: list[dict[str, Any]]
     store: Store
 
     @staticmethod
-    def from_vega(name: str, signal: Optional[Dict[str, dict]], store: Store):
+    def from_vega(name: str, signal: dict[str, dict] | None, store: Store):
         """
         Construct a PointSelection from the raw Vega signal and dataset values.
 
@@ -89,10 +90,7 @@ def from_vega(name: str, signal: Optional[Dict[str, dict]], store: Store):
         -------
         PointSelection
         """
-        if signal is None:
-            points = []
-        else:
-            points = signal.get("vlPoint", {}).get("or", [])
+        points = [] if signal is None else signal.get("vlPoint", {}).get("or", [])
         return PointSelection(name=name, value=points, store=store)
 
 
@@ -110,11 +108,11 @@ class IntervalSelection:
     """
 
     name: str
-    value: Dict[str, list]
+    value: dict[str, list]
     store: Store
 
     @staticmethod
-    def from_vega(name: str, signal: Optional[Dict[str, list]], store: Store):
+    def from_vega(name: str, signal: dict[str, list] | None, store: Store):
         """
         Construct an IntervalSelection from the raw Vega signal and dataset values.
 
diff --git a/altair/utils/server.py b/altair/utils/server.py
index 2ec2b32fc..a9f1000a7 100644
--- a/altair/utils/server.py
+++ b/altair/utils/server.py
@@ -79,7 +79,8 @@ def find_open_port(ip, port, n=50):
         s.close()
         if result != 0:
             return port
-    raise ValueError("no open ports found")
+    msg = "no open ports found"
+    raise ValueError(msg)
 
 
 def serve(
@@ -91,7 +92,7 @@ def serve(
     jupyter_warning=True,
     open_browser=True,
     http_server=None,
-):
+) -> None:
     """Start a server serving the given HTML, and (optionally) open a browser
 
     Parameters
@@ -124,20 +125,20 @@ def serve(
 
     if jupyter_warning:
         try:
-            __IPYTHON__  # noqa
+            __IPYTHON__  # type: ignore # noqa
         except NameError:
             pass
         else:
             print(JUPYTER_WARNING)
 
     # Start the server
-    print("Serving to http://{}:{}/    [Ctrl-C to exit]".format(ip, port))
+    print(f"Serving to http://{ip}:{port}/    [Ctrl-C to exit]")
     sys.stdout.flush()
 
     if open_browser:
         # Use a thread to open a web browser pointing to the server
         def b():
-            return webbrowser.open("http://{}:{}".format(ip, port))
+            return webbrowser.open(f"http://{ip}:{port}")
 
         threading.Thread(target=b).start()
 
diff --git a/altair/vegalite/data.py b/altair/vegalite/data.py
index 5b7a90a3d..db5b4bcdc 100644
--- a/altair/vegalite/data.py
+++ b/altair/vegalite/data.py
@@ -1,3 +1,6 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, overload, Callable
+
 from ..utils.core import sanitize_dataframe
 from ..utils.data import (
     MaxRowsError,
@@ -9,9 +12,10 @@
     check_data_type,
 )
 from ..utils.data import DataTransformerRegistry as _DataTransformerRegistry
-from ..utils.data import DataType, ToValuesReturnType
-from ..utils.plugin_registry import PluginEnabler
-from typing import Optional, Union, overload, Callable
+
+if TYPE_CHECKING:
+    from ..utils.plugin_registry import PluginEnabler
+    from ..utils.data import DataType, ToValuesReturnType
 
 
 @overload
@@ -23,8 +27,8 @@ def default_data_transformer(
     data: DataType, max_rows: int = ...
 ) -> ToValuesReturnType: ...
 def default_data_transformer(
-    data: Optional[DataType] = None, max_rows: int = 5000
-) -> Union[Callable[[DataType], ToValuesReturnType], ToValuesReturnType]:
+    data: DataType | None = None, max_rows: int = 5000
+) -> Callable[[DataType], ToValuesReturnType] | ToValuesReturnType:
     if data is None:
 
         def pipe(data: DataType, /) -> ToValuesReturnType:
@@ -41,7 +45,7 @@ class DataTransformerRegistry(_DataTransformerRegistry):
     def disable_max_rows(self) -> PluginEnabler:
         """Disable the MaxRowsError."""
         options = self.options
-        if self.active in ("default", "vegafusion"):
+        if self.active in {"default", "vegafusion"}:
             options = options.copy()
             options["max_rows"] = None
         return self.enable(**options)
@@ -50,12 +54,12 @@ def disable_max_rows(self) -> PluginEnabler:
 __all__ = (
     "DataTransformerRegistry",
     "MaxRowsError",
-    "sanitize_dataframe",
+    "check_data_type",
     "default_data_transformer",
     "limit_rows",
     "sample",
+    "sanitize_dataframe",
     "to_csv",
     "to_json",
     "to_values",
-    "check_data_type",
 )
diff --git a/altair/vegalite/display.py b/altair/vegalite/display.py
index 1f3a13b46..d146c53c7 100644
--- a/altair/vegalite/display.py
+++ b/altair/vegalite/display.py
@@ -8,10 +8,10 @@
 
 
 __all__ = (
+    "DefaultRendererReturnType",
     "Displayable",
+    "HTMLRenderer",
+    "RendererRegistry",
     "default_renderer_base",
     "json_renderer_base",
-    "RendererRegistry",
-    "HTMLRenderer",
-    "DefaultRendererReturnType",
 )
diff --git a/altair/vegalite/v5/__init__.py b/altair/vegalite/v5/__init__.py
index 17c61a6e5..f921d662e 100644
--- a/altair/vegalite/v5/__init__.py
+++ b/altair/vegalite/v5/__init__.py
@@ -2,7 +2,7 @@
 from .schema import *
 from .api import *
 
-from ...expr import datum, expr  # type: ignore[no-redef]
+from ...expr import datum, expr
 
 from .display import VegaLite, renderers
 from .compiler import vegalite_compilers
diff --git a/altair/vegalite/v5/api.py b/altair/vegalite/v5/api.py
index 6425c77fe..747ed5a5e 100644
--- a/altair/vegalite/v5/api.py
+++ b/altair/vegalite/v5/api.py
@@ -1,23 +1,19 @@
-import warnings
+from __future__ import annotations
 
+import warnings
 import hashlib
 import io
 import json
 import jsonschema
 import itertools
-import sys
-import pathlib
-import typing
-from typing import cast, List, Optional, Any, Iterable, Union, Literal, IO
+from typing import Union, cast, Any, Iterable, Literal, IO, TYPE_CHECKING
+from typing_extensions import TypeAlias
 
-# Have to rename it here as else it overlaps with schema.core.Type and schema.core.Dict
-from typing import Type as TypingType
-from typing import Dict as TypingDict
-
-from .schema import core, channels, mixins, Undefined, UndefinedType, SCHEMA_URL
+from .schema import core, channels, mixins, Undefined, SCHEMA_URL
 
+from altair.utils import Optional
 from .data import data_transformers
-from ... import utils, expr
+from ... import utils
 from ...expr import core as _expr_core
 from .display import renderers, VEGALITE_VERSION, VEGAEMBED_VERSION, VEGA_VERSION
 from .theme import themes
@@ -26,25 +22,77 @@
     using_vegafusion as _using_vegafusion,
     compile_with_vegafusion as _compile_with_vegafusion,
 )
-from ...utils.core import DataFrameLike
 from ...utils.data import DataType, is_data_type as _is_data_type
 from ...utils.deprecation import AltairDeprecationWarning
 
-if sys.version_info >= (3, 13):
-    from typing import TypeIs
-else:
-    from typing_extensions import TypeIs
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+if TYPE_CHECKING:
+    from ...utils.core import DataFrameLike
+    import sys
+    from pathlib import Path
+
+    if sys.version_info >= (3, 13):
+        from typing import TypeIs
+    else:
+        from typing_extensions import TypeIs
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+    from .schema.channels import Facet, Row, Column
+    from .schema.core import (
+        SchemaBase,
+        Expr,
+        PredicateComposition,
+        Binding,
+        IntervalSelectionConfig,
+        PointSelectionConfig,
+        Mark,
+        LayerRepeatMapping,
+        RepeatMapping,
+        ProjectionType,
+        ExprRef,
+        Vector2number,
+        Vector2Vector2number,
+        Vector3number,
+        Transform,
+        AggregatedFieldDef,
+        FieldName,
+        BinParams,
+        ImputeSequence,
+        ImputeMethod,
+        JoinAggregateFieldDef,
+        ParameterName,
+        Predicate,
+        LookupSelection,
+        AggregateOp,
+        SortField,
+        TimeUnit,
+        WindowFieldDef,
+        FacetFieldDef,
+        FacetedEncoding,
+        AnyMark,
+        Step,
+        RepeatRef,
+        NonNormalizedSpec,
+        LayerSpec,
+        UnitSpec,
+        UrlData,
+        SequenceGenerator,
+        GraticuleGenerator,
+        SphereGenerator,
+        VariableParameter,
+        TopLevelSelectionParameter,
+        SelectionParameter,
+        InlineDataset,
+    )
+    from altair.expr.core import Expression, GetAttrExpression
 
-ChartDataType = Union[DataType, core.Data, str, core.Generator, UndefinedType]
+ChartDataType: TypeAlias = Optional[Union[DataType, core.Data, str, core.Generator]]
 
 
 # ------------------------------------------------------------------------
 # Data Utilities
-def _dataset_name(values: Union[dict, list, core.InlineDataset]) -> str:
+def _dataset_name(values: dict | list | InlineDataset) -> str:
     """Generate a unique hash of the data
 
     Parameters
@@ -82,10 +130,9 @@ def _consolidate_data(data, context):
                 values = data.values
             kwds = {"format": data.format}
 
-    elif isinstance(data, dict):
-        if "name" not in data and "values" in data:
-            values = data["values"]
-            kwds = {k: v for k, v in data.items() if k != "values"}
+    elif isinstance(data, dict) and "name" not in data and "values" in data:
+        values = data["values"]
+        kwds = {k: v for k, v in data.items() if k != "values"}
 
     if values is not Undefined:
         name = _dataset_name(values)
@@ -126,7 +173,7 @@ def _prepare_data(data, context=None):
 
     # if data is still not a recognized type, then return
     if not isinstance(data, (dict, core.Data)):
-        warnings.warn("data of type {} not recognized".format(type(data)), stacklevel=1)
+        warnings.warn(f"data of type {type(data)} not recognized", stacklevel=1)
 
     return data
 
@@ -179,8 +226,8 @@ def to_dict(self, *args, **kwargs) -> dict:
 TOPLEVEL_ONLY_KEYS = {"background", "config", "autosize", "padding", "$schema"}
 
 
-def _get_channels_mapping() -> TypingDict[TypingType[core.SchemaBase], str]:
-    mapping: TypingDict[TypingType[core.SchemaBase], str] = {}
+def _get_channels_mapping() -> dict[type[SchemaBase], str]:
+    mapping: dict[type[SchemaBase], str] = {}
     for attr in dir(channels):
         cls = getattr(channels, attr)
         if isinstance(cls, type) and issubclass(cls, core.SchemaBase):
@@ -205,15 +252,12 @@ def _get_name(cls) -> str:
 
     def __init__(
         self,
-        name: Optional[str] = None,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[
-            core.VariableParameter,
-            core.TopLevelSelectionParameter,
-            core.SelectionParameter,
-            UndefinedType,
+        name: str | None = None,
+        empty: Optional[bool] = Undefined,
+        param: Optional[
+            VariableParameter | TopLevelSelectionParameter | SelectionParameter
         ] = Undefined,
-        param_type: Union[Literal["variable", "selection"], UndefinedType] = Undefined,
+        param_type: Optional[Literal["variable", "selection"]] = Undefined,
     ) -> None:
         if name is None:
             name = self._get_name()
@@ -229,7 +273,7 @@ def ref(self) -> dict:
         "'ref' is deprecated. No need to call '.ref()' anymore."
         return self.to_dict()
 
-    def to_dict(self) -> TypingDict[str, Union[str, dict]]:
+    def to_dict(self) -> dict[str, str | dict]:
         if self.param_type == "variable":
             return {"expr": self.name}
         elif self.param_type == "selection":
@@ -239,7 +283,8 @@ def to_dict(self) -> TypingDict[str, Union[str, dict]]:
                 )
             }
         else:
-            raise ValueError(f"Unrecognized parameter type: {self.param_type}")
+            msg = f"Unrecognized parameter type: {self.param_type}"
+            raise ValueError(msg)
 
     def __invert__(self):
         if self.param_type == "selection":
@@ -264,17 +309,15 @@ def __or__(self, other):
             return _expr_core.OperatorMixin.__or__(self, other)
 
     def __repr__(self) -> str:
-        return "Parameter({0!r}, {1})".format(self.name, self.param)
+        return f"Parameter({self.name!r}, {self.param})"
 
     def _to_expr(self) -> str:
         return self.name
 
-    def _from_expr(self, expr) -> "ParameterExpression":
+    def _from_expr(self, expr) -> ParameterExpression:
         return ParameterExpression(expr=expr)
 
-    def __getattr__(
-        self, field_name: str
-    ) -> Union[_expr_core.GetAttrExpression, "SelectionExpression"]:
+    def __getattr__(self, field_name: str) -> GetAttrExpression | SelectionExpression:
         if field_name.startswith("__") and field_name.endswith("__"):
             raise AttributeError(field_name)
         _attrexpr = _expr_core.GetAttrExpression(self.name, field_name)
@@ -302,31 +345,31 @@ def __or__(self, other):
         return SelectionPredicateComposition({"or": [self.to_dict(), other.to_dict()]})
 
 
-class ParameterExpression(_expr_core.OperatorMixin, object):
+class ParameterExpression(_expr_core.OperatorMixin):
     def __init__(self, expr) -> None:
         self.expr = expr
 
-    def to_dict(self) -> TypingDict[str, str]:
+    def to_dict(self) -> dict[str, str]:
         return {"expr": repr(self.expr)}
 
     def _to_expr(self) -> str:
         return repr(self.expr)
 
-    def _from_expr(self, expr) -> "ParameterExpression":
+    def _from_expr(self, expr) -> ParameterExpression:
         return ParameterExpression(expr=expr)
 
 
-class SelectionExpression(_expr_core.OperatorMixin, object):
+class SelectionExpression(_expr_core.OperatorMixin):
     def __init__(self, expr) -> None:
         self.expr = expr
 
-    def to_dict(self) -> TypingDict[str, str]:
+    def to_dict(self) -> dict[str, str]:
         return {"expr": repr(self.expr)}
 
     def _to_expr(self) -> str:
         return repr(self.expr)
 
-    def _from_expr(self, expr) -> "SelectionExpression":
+    def _from_expr(self, expr) -> SelectionExpression:
         return SelectionExpression(expr=expr)
 
 
@@ -351,11 +394,11 @@ def value(value, **kwargs) -> dict:
 
 
 def param(
-    name: Optional[str] = None,
-    value: Union[Any, UndefinedType] = Undefined,
-    bind: Union[core.Binding, UndefinedType] = Undefined,
-    empty: Union[bool, UndefinedType] = Undefined,
-    expr: Union[str, core.Expr, _expr_core.Expression, UndefinedType] = Undefined,
+    name: str | None = None,
+    value: Optional[Any] = Undefined,
+    bind: Optional[Binding] = Undefined,
+    empty: Optional[bool] = Undefined,
+    expr: Optional[str | Expr | Expression] = Undefined,
     **kwds,
 ) -> Parameter:
     """Create a named parameter.
@@ -414,7 +457,8 @@ def param(
         elif (parameter.empty is False) or (parameter.empty is True):
             pass
         else:
-            raise ValueError("The value of 'empty' should be True or False.")
+            msg = "The value of 'empty' should be True or False."
+            raise ValueError(msg)
 
     if "init" in kwds:
         warnings.warn(
@@ -453,21 +497,19 @@ def param(
 
 
 def _selection(
-    type: Union[Literal["interval", "point"], UndefinedType] = Undefined, **kwds
+    type: Optional[Literal["interval", "point"]] = Undefined, **kwds
 ) -> Parameter:
     # We separate out the parameter keywords from the selection keywords
-    param_kwds = {}
 
-    for kwd in {"name", "bind", "value", "empty", "init", "views"}:
-        if kwd in kwds:
-            param_kwds[kwd] = kwds.pop(kwd)
+    select_kwds = {"name", "bind", "value", "empty", "init", "views"}
+    param_kwds = {key: kwds.pop(key) for key in select_kwds & kwds.keys()}
 
-    select: Union[core.IntervalSelectionConfig, core.PointSelectionConfig]
+    select: IntervalSelectionConfig | PointSelectionConfig
     if type == "interval":
         select = core.IntervalSelectionConfig(type=type, **kwds)
     elif type == "point":
         select = core.PointSelectionConfig(type=type, **kwds)
-    elif type in ["single", "multi"]:
+    elif type in {"single", "multi"}:
         select = core.PointSelectionConfig(type="point", **kwds)
         warnings.warn(
             """The types 'single' and 'multi' are now
@@ -476,7 +518,8 @@ def _selection(
             stacklevel=1,
         )
     else:
-        raise ValueError("""'type' must be 'point' or 'interval'""")
+        msg = """'type' must be 'point' or 'interval'"""
+        raise ValueError(msg)
 
     return param(select=select, **param_kwds)
 
@@ -486,7 +529,7 @@ def _selection(
    Use 'selection_point()' or 'selection_interval()' instead; these functions also include more helpful docstrings."""
 )
 def selection(
-    type: Union[Literal["interval", "point"], UndefinedType] = Undefined, **kwds
+    type: Optional[Literal["interval", "point"]] = Undefined, **kwds
 ) -> Parameter:
     """
     Users are recommended to use either 'selection_point' or 'selection_interval' instead, depending on the type of parameter they want to create.
@@ -511,18 +554,18 @@ def selection(
 
 
 def selection_interval(
-    name: Optional[str] = None,
-    value: Union[Any, UndefinedType] = Undefined,
-    bind: Union[core.Binding, str, UndefinedType] = Undefined,
-    empty: Union[bool, UndefinedType] = Undefined,
-    expr: Union[str, core.Expr, _expr_core.Expression, UndefinedType] = Undefined,
-    encodings: Union[List[str], UndefinedType] = Undefined,
-    on: Union[str, UndefinedType] = Undefined,
-    clear: Union[str, bool, UndefinedType] = Undefined,
-    resolve: Union[Literal["global", "union", "intersect"], UndefinedType] = Undefined,
-    mark: Union[core.Mark, UndefinedType] = Undefined,
-    translate: Union[str, bool, UndefinedType] = Undefined,
-    zoom: Union[str, bool, UndefinedType] = Undefined,
+    name: str | None = None,
+    value: Optional[Any] = Undefined,
+    bind: Optional[Binding | str] = Undefined,
+    empty: Optional[bool] = Undefined,
+    expr: Optional[str | Expr | Expression] = Undefined,
+    encodings: Optional[list[str]] = Undefined,
+    on: Optional[str] = Undefined,
+    clear: Optional[str | bool] = Undefined,
+    resolve: Optional[Literal["global", "union", "intersect"]] = Undefined,
+    mark: Optional[Mark] = Undefined,
+    translate: Optional[str | bool] = Undefined,
+    zoom: Optional[str | bool] = Undefined,
     **kwds,
 ) -> Parameter:
     """Create an interval selection parameter. Selection parameters define data queries that are driven by direct manipulation from user input (e.g., mouse clicks or drags). Interval selection parameters are used to select a continuous range of data values on drag, whereas point selection parameters (`selection_point`) are used to select multiple discrete data values.)
@@ -623,18 +666,18 @@ def selection_interval(
 
 
 def selection_point(
-    name: Optional[str] = None,
-    value: Union[Any, UndefinedType] = Undefined,
-    bind: Union[core.Binding, str, UndefinedType] = Undefined,
-    empty: Union[bool, UndefinedType] = Undefined,
-    expr: Union[core.Expr, UndefinedType] = Undefined,
-    encodings: Union[List[str], UndefinedType] = Undefined,
-    fields: Union[List[str], UndefinedType] = Undefined,
-    on: Union[str, UndefinedType] = Undefined,
-    clear: Union[str, bool, UndefinedType] = Undefined,
-    resolve: Union[Literal["global", "union", "intersect"], UndefinedType] = Undefined,
-    toggle: Union[str, bool, UndefinedType] = Undefined,
-    nearest: Union[bool, UndefinedType] = Undefined,
+    name: str | None = None,
+    value: Optional[Any] = Undefined,
+    bind: Optional[Binding | str] = Undefined,
+    empty: Optional[bool] = Undefined,
+    expr: Optional[Expr] = Undefined,
+    encodings: Optional[list[str]] = Undefined,
+    fields: Optional[list[str]] = Undefined,
+    on: Optional[str] = Undefined,
+    clear: Optional[str | bool] = Undefined,
+    resolve: Optional[Literal["global", "union", "intersect"]] = Undefined,
+    toggle: Optional[str | bool] = Undefined,
+    nearest: Optional[bool] = Undefined,
     **kwds,
 ) -> Parameter:
     """Create a point selection parameter. Selection parameters define data queries that are driven by direct manipulation from user input (e.g., mouse clicks or drags). Point selection parameters are used to select multiple discrete data values; the first value is selected on click and additional values toggled on shift-click. To select a continuous range of data values on drag interval selection parameters (`selection_interval`) can be used instead.
@@ -788,15 +831,18 @@ def binding_range(**kwargs):
 
 # TODO: update the docstring
 def condition(
-    predicate: Union[
-        Parameter, str, expr.Expression, core.Expr, core.PredicateComposition, dict
-    ],
+    predicate: Parameter
+    | str
+    | Expression
+    | Expr
+    | PredicateComposition
+    | dict[str, Any],
     # Types of these depends on where the condition is used so we probably
     # can't be more specific here.
     if_true: Any,
     if_false: Any,
     **kwargs,
-) -> Union[dict, core.SchemaBase]:
+) -> dict[str, Any] | SchemaBase:
     """A conditional attribute or encoding
 
     Parameters
@@ -816,14 +862,10 @@ def condition(
     spec: dict or VegaLiteSchema
         the spec that describes the condition
     """
-    test_predicates = (str, expr.Expression, core.PredicateComposition)
-
-    condition: TypingDict[
-        str,
-        Union[
-            bool, str, _expr_core.Expression, core.PredicateComposition, UndefinedType
-        ],
-    ]
+
+    test_predicates = (str, _expr_core.Expression, core.PredicateComposition)
+
+    condition: dict[str, Optional[bool | str | Expression | PredicateComposition]]
     if isinstance(predicate, Parameter):
         if (
             predicate.param_type == "selection"
@@ -841,9 +883,8 @@ def condition(
     elif isinstance(predicate, dict):
         condition = predicate
     else:
-        raise NotImplementedError(
-            "condition predicate of type {}" "".format(type(predicate))
-        )
+        msg = f"condition predicate of type {type(predicate)}" ""
+        raise NotImplementedError(msg)
 
     if isinstance(if_true, core.SchemaBase):
         # convert to dict for now; the from_dict call below will wrap this
@@ -851,15 +892,14 @@ def condition(
         if_true = if_true.to_dict()
     elif isinstance(if_true, str):
         if isinstance(if_false, str):
-            raise ValueError(
-                "A field cannot be used for both the `if_true` and `if_false` values of a condition. One of them has to specify a `value` or `datum` definition."
-            )
+            msg = "A field cannot be used for both the `if_true` and `if_false` values of a condition. One of them has to specify a `value` or `datum` definition."
+            raise ValueError(msg)
         else:
             if_true = utils.parse_shorthand(if_true)
             if_true.update(kwargs)
     condition.update(if_true)
 
-    selection: Union[dict, core.SchemaBase]
+    selection: dict | SchemaBase
     if isinstance(if_false, core.SchemaBase):
         # For the selection, the channel definitions all allow selections
         # already. So use this SchemaBase wrapper if possible.
@@ -888,8 +928,8 @@ def to_dict(
         validate: bool = True,
         *,
         format: str = "vega-lite",
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict:
         """Convert the chart to a dictionary suitable for JSON export
 
@@ -924,10 +964,9 @@ def to_dict(
         """
 
         # Validate format
-        if format not in ("vega-lite", "vega"):
-            raise ValueError(
-                f'The format argument must be either "vega-lite" or "vega". Received {repr(format)}'
-            )
+        if format not in {"vega-lite", "vega"}:
+            msg = f'The format argument must be either "vega-lite" or "vega". Received {format!r}'
+            raise ValueError(msg)
 
         # We make use of three context markers:
         # - 'data' points to the data that should be referenced for column type
@@ -984,7 +1023,7 @@ def to_dict(
 
         if context.get("pre_transform", True) and _using_vegafusion():
             if format == "vega-lite":
-                raise ValueError(
+                msg = (
                     'When the "vegafusion" data transformer is enabled, the \n'
                     "to_dict() and to_json() chart methods must be called with "
                     'format="vega". \n'
@@ -992,26 +1031,27 @@ def to_dict(
                     '    >>> chart.to_dict(format="vega")\n'
                     '    >>> chart.to_json(format="vega")'
                 )
+                raise ValueError(msg)
             else:
                 return _compile_with_vegafusion(vegalite_spec)
+        elif format == "vega":
+            plugin = vegalite_compilers.get()
+            if plugin is None:
+                msg = "No active vega-lite compiler plugin found"
+                raise ValueError(msg)
+            return plugin(vegalite_spec)
         else:
-            if format == "vega":
-                plugin = vegalite_compilers.get()
-                if plugin is None:
-                    raise ValueError("No active vega-lite compiler plugin found")
-                return plugin(vegalite_spec)
-            else:
-                return vegalite_spec
+            return vegalite_spec
 
     def to_json(
         self,
         validate: bool = True,
-        indent: Optional[Union[int, str]] = 2,
+        indent: int | str | None = 2,
         sort_keys: bool = True,
         *,
         format: str = "vega-lite",
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
         **kwargs,
     ) -> str:
         """Convert a chart to a JSON string
@@ -1051,8 +1091,8 @@ def to_html(
         self,
         base_url: str = "https://cdn.jsdelivr.net/npm",
         output_div: str = "vis",
-        embed_options: Optional[dict] = None,
-        json_kwds: Optional[dict] = None,
+        embed_options: dict | None = None,
+        json_kwds: dict | None = None,
         fullhtml: bool = True,
         requirejs: bool = False,
         inline: bool = False,
@@ -1140,18 +1180,18 @@ def open_editor(self, *, fullscreen: bool = False) -> None:
 
     def save(
         self,
-        fp: Union[str, pathlib.Path, IO],
-        format: Optional[Literal["json", "html", "png", "svg", "pdf"]] = None,
+        fp: str | Path | IO,
+        format: Literal["json", "html", "png", "svg", "pdf"] | None = None,
         override_data_transformer: bool = True,
         scale_factor: float = 1.0,
-        mode: Optional[str] = None,
+        mode: str | None = None,
         vegalite_version: str = VEGALITE_VERSION,
         vega_version: str = VEGA_VERSION,
         vegaembed_version: str = VEGAEMBED_VERSION,
-        embed_options: Optional[dict] = None,
-        json_kwds: Optional[dict] = None,
-        webdriver: Optional[str] = None,
-        engine: Optional[str] = None,
+        embed_options: dict | None = None,
+        json_kwds: dict | None = None,
+        webdriver: str | None = None,
+        engine: str | None = None,
         inline=False,
         **kwargs,
     ) -> None:
@@ -1237,39 +1277,41 @@ def save(
                 save(**kwds)
         else:
             save(**kwds)
-        return
 
     # Fallback for when rendering fails; the full repr is too long to be
     # useful in nearly all cases.
     def __repr__(self) -> str:
-        return "alt.{}(...)".format(self.__class__.__name__)
+        return f"alt.{self.__class__.__name__}(...)"
 
     # Layering and stacking
-    def __add__(self, other) -> "LayerChart":
+    def __add__(self, other) -> LayerChart:
         if not isinstance(other, TopLevelMixin):
-            raise ValueError("Only Chart objects can be layered.")
+            msg = "Only Chart objects can be layered."
+            raise ValueError(msg)
         return layer(self, other)
 
-    def __and__(self, other) -> "VConcatChart":
+    def __and__(self, other) -> VConcatChart:
         if not isinstance(other, TopLevelMixin):
-            raise ValueError("Only Chart objects can be concatenated.")
+            msg = "Only Chart objects can be concatenated."
+            raise ValueError(msg)
         # Too difficult to type check this
         return vconcat(self, other)
 
-    def __or__(self, other) -> "HConcatChart":
+    def __or__(self, other) -> HConcatChart:
         if not isinstance(other, TopLevelMixin):
-            raise ValueError("Only Chart objects can be concatenated.")
+            msg = "Only Chart objects can be concatenated."
+            raise ValueError(msg)
         return hconcat(self, other)
 
     def repeat(
         self,
-        repeat: Union[List[str], UndefinedType] = Undefined,
-        row: Union[List[str], UndefinedType] = Undefined,
-        column: Union[List[str], UndefinedType] = Undefined,
-        layer: Union[List[str], UndefinedType] = Undefined,
-        columns: Union[int, UndefinedType] = Undefined,
+        repeat: Optional[list[str]] = Undefined,
+        row: Optional[list[str]] = Undefined,
+        column: Optional[list[str]] = Undefined,
+        layer: Optional[list[str]] = Undefined,
+        columns: Optional[int] = Undefined,
         **kwargs,
-    ) -> "RepeatChart":
+    ) -> RepeatChart:
         """Return a RepeatChart built from the chart
 
         Fields within the chart can be set to correspond to the row or
@@ -1303,15 +1345,15 @@ def repeat(
         layer_specified = layer is not Undefined
 
         if repeat_specified and rowcol_specified:
-            raise ValueError(
-                "repeat argument cannot be combined with row/column argument."
-            )
+            msg = "repeat argument cannot be combined with row/column argument."
+            raise ValueError(msg)
         elif repeat_specified and layer_specified:
-            raise ValueError("repeat argument cannot be combined with layer argument.")
+            msg = "repeat argument cannot be combined with layer argument."
+            raise ValueError(msg)
 
-        repeat_arg: Union[List[str], core.LayerRepeatMapping, core.RepeatMapping]
+        repeat_arg: list[str] | LayerRepeatMapping | RepeatMapping
         if repeat_specified:
-            assert not isinstance(repeat, UndefinedType)  # For mypy
+            assert isinstance(repeat, list)
             repeat_arg = repeat
         elif layer_specified:
             repeat_arg = core.LayerRepeatMapping(layer=layer, row=row, column=column)
@@ -1343,45 +1385,30 @@ def properties(self, **kwargs) -> Self:
 
     def project(
         self,
-        type: Union[
-            str, core.ProjectionType, core.ExprRef, Parameter, UndefinedType
-        ] = Undefined,
-        center: Union[
-            List[float], core.Vector2number, core.ExprRef, Parameter, UndefinedType
+        type: Optional[str | ProjectionType | ExprRef | Parameter] = Undefined,
+        center: Optional[list[float] | Vector2number | ExprRef | Parameter] = Undefined,
+        clipAngle: Optional[float | ExprRef | Parameter] = Undefined,
+        clipExtent: Optional[
+            list[list[float]] | Vector2Vector2number | ExprRef | Parameter
         ] = Undefined,
-        clipAngle: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        clipExtent: Union[
-            List[List[float]],
-            core.Vector2Vector2number,
-            core.ExprRef,
-            Parameter,
-            UndefinedType,
+        coefficient: Optional[float | ExprRef | Parameter] = Undefined,
+        distance: Optional[float | ExprRef | Parameter] = Undefined,
+        fraction: Optional[float | ExprRef | Parameter] = Undefined,
+        lobes: Optional[float | ExprRef | Parameter] = Undefined,
+        parallel: Optional[float | ExprRef | Parameter] = Undefined,
+        precision: Optional[float | ExprRef | Parameter] = Undefined,
+        radius: Optional[float | ExprRef | Parameter] = Undefined,
+        ratio: Optional[float | ExprRef | Parameter] = Undefined,
+        reflectX: Optional[bool | ExprRef | Parameter] = Undefined,
+        reflectY: Optional[bool | ExprRef | Parameter] = Undefined,
+        rotate: Optional[
+            list[float] | Vector2number | Vector3number | ExprRef | Parameter
         ] = Undefined,
-        coefficient: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        distance: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        fraction: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        lobes: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        parallel: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        precision: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        radius: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        ratio: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        reflectX: Union[bool, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        reflectY: Union[bool, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        rotate: Union[
-            List[float],
-            core.Vector2number,
-            core.Vector3number,
-            core.ExprRef,
-            Parameter,
-            UndefinedType,
-        ] = Undefined,
-        scale: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        spacing: Union[
-            float, core.Vector2number, core.ExprRef, Parameter, UndefinedType
-        ] = Undefined,
-        tilt: Union[float, core.ExprRef, Parameter, UndefinedType] = Undefined,
-        translate: Union[
-            List[float], core.Vector2number, core.ExprRef, Parameter, UndefinedType
+        scale: Optional[float | ExprRef | Parameter] = Undefined,
+        spacing: Optional[float | Vector2number | ExprRef | Parameter] = Undefined,
+        tilt: Optional[float | ExprRef | Parameter] = Undefined,
+        translate: Optional[
+            list[float] | Vector2number | ExprRef | Parameter
         ] = Undefined,
         **kwds,
     ) -> Self:
@@ -1405,16 +1432,16 @@ def project(
 
             **Default value:** `equalEarth`
         center : List(float)
-            Sets the projection’s center to the specified center, a two-element array of
+            Sets the projection's center to the specified center, a two-element array of
             longitude and latitude in degrees.
 
             **Default value:** `[0, 0]`
         clipAngle : float
-            Sets the projection’s clipping circle radius to the specified angle in degrees. If
+            Sets the projection's clipping circle radius to the specified angle in degrees. If
             `null`, switches to [antimeridian](http://bl.ocks.org/mbostock/3788999) cutting
             rather than small-circle clipping.
         clipExtent : List(List(float))
-            Sets the projection’s viewport clip extent to the specified bounds in pixels. The
+            Sets the projection's viewport clip extent to the specified bounds in pixels. The
             extent bounds are specified as an array `[[x0, y0], [x1, y1]]`, where `x0` is the
             left-side of the viewport, `y0` is the top, `x1` is the right and `y1` is the
             bottom. If `null`, no viewport clipping is performed.
@@ -1424,7 +1451,7 @@ def project(
             **Default value:** ``2``
         distance : float
             For the ``satellite`` projection, the distance from the center of the sphere to the
-            point of view, as a proportion of the sphere’s radius. The recommended maximum clip
+            point of view, as a proportion of the sphere's radius. The recommended maximum clip
             angle for a given ``distance`` is acos(1 / distance) converted to degrees. If tilt
             is also applied, then more conservative clipping may be necessary.
 
@@ -1441,11 +1468,11 @@ def project(
             <https://en.wikipedia.org/wiki/Map_projection#Conic>`__ that define the map layout.
             The default depends on the specific conic projection used.
         precision : float
-            Sets the threshold for the projection’s [adaptive
+            Sets the threshold for the projection's [adaptive
             resampling](http://bl.ocks.org/mbostock/3795544) to the specified value in pixels.
-            This value corresponds to the [Douglas–Peucker
+            This value corresponds to the [Douglas-Peucker
             distance](http://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm).
-             If precision is not specified, returns the projection’s current resampling
+             If precision is not specified, returns the projection's current resampling
             precision which defaults to `√0.5 ≅ 0.70710…`.
         radius : float
             The radius parameter for the ``airy`` or ``gingery`` projection. The default value
@@ -1458,14 +1485,14 @@ def project(
         reflectY : boolean
             Sets whether or not the y-dimension is reflected (negated) in the output.
         rotate : List(float)
-            Sets the projection’s three-axis rotation to the specified angles, which must be a
+            Sets the projection's three-axis rotation to the specified angles, which must be a
             two- or three-element array of numbers [`lambda`, `phi`, `gamma`] specifying the
             rotation angles in degrees about each spherical axis. (These correspond to yaw,
             pitch and roll.)
 
             **Default value:** `[0, 0, 0]`
         scale : float
-            The projection’s scale (zoom) factor, overriding automatic fitting. The default
+            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.
@@ -1478,7 +1505,7 @@ def project(
 
             **Default value:** ``0``.
         translate : List(float)
-            The projection’s translation offset as a two-element array ``[tx, ty]``,
+            The projection's translation offset as a two-element array ``[tx, ty]``,
             overriding automatic fitting.
 
         """
@@ -1508,7 +1535,7 @@ def project(
         )
         return self.properties(projection=projection)
 
-    def _add_transform(self, *transforms: core.Transform) -> Self:
+    def _add_transform(self, *transforms: Transform) -> Self:
         """Copy the chart and add specified transforms to chart.transform"""
         copy = self.copy(deep=["transform"])  # type: ignore[attr-defined]
         if copy.transform is Undefined:
@@ -1518,9 +1545,9 @@ def _add_transform(self, *transforms: core.Transform) -> Self:
 
     def transform_aggregate(
         self,
-        aggregate: Union[List[core.AggregatedFieldDef], UndefinedType] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        **kwds: Union[TypingDict[str, Any], str],
+        aggregate: Optional[list[AggregatedFieldDef]] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
+        **kwds: dict[str, Any] | str,
     ) -> Self:
         """
         Add an :class:`AggregateTransform` to the schema.
@@ -1590,7 +1617,7 @@ def transform_aggregate(
                 "field": parsed.get("field", Undefined),
                 "op": parsed.get("aggregate", Undefined),
             }
-            assert not isinstance(aggregate, UndefinedType)  # For mypy
+            assert isinstance(aggregate, list)
             aggregate.append(core.AggregatedFieldDef(**dct))
         return self._add_transform(
             core.AggregateTransform(aggregate=aggregate, groupby=groupby)
@@ -1598,11 +1625,9 @@ def transform_aggregate(
 
     def transform_bin(
         self,
-        as_: Union[
-            str, core.FieldName, List[Union[str, core.FieldName]], UndefinedType
-        ] = Undefined,
-        field: Union[str, core.FieldName, UndefinedType] = Undefined,
-        bin: Union[Literal[True], core.BinParams] = True,
+        as_: Optional[str | FieldName | list[str | FieldName]] = Undefined,
+        field: Optional[str | FieldName] = Undefined,
+        bin: Literal[True] | BinParams = True,
         **kwargs,
     ) -> Self:
         """
@@ -1652,9 +1677,8 @@ def transform_bin(
         """
         if as_ is not Undefined:
             if "as" in kwargs:
-                raise ValueError(
-                    "transform_bin: both 'as_' and 'as' passed as arguments."
-                )
+                msg = "transform_bin: both 'as_' and 'as' passed as arguments."
+                raise ValueError(msg)
             kwargs["as"] = as_
         kwargs["bin"] = bin
         kwargs["field"] = field
@@ -1662,11 +1686,9 @@ def transform_bin(
 
     def transform_calculate(
         self,
-        as_: Union[str, core.FieldName, UndefinedType] = Undefined,
-        calculate: Union[
-            str, core.Expr, _expr_core.Expression, UndefinedType
-        ] = Undefined,
-        **kwargs: Union[str, core.Expr, _expr_core.Expression],
+        as_: Optional[str | FieldName] = Undefined,
+        calculate: Optional[str | Expr | Expression] = Undefined,
+        **kwargs: str | Expr | Expression,
     ) -> Self:
         """
         Add a :class:`CalculateTransform` to the schema.
@@ -1722,9 +1744,8 @@ def transform_calculate(
             # users.
             as_ = kwargs.pop("as", Undefined)  # type: ignore[assignment]
         elif "as" in kwargs:
-            raise ValueError(
-                "transform_calculate: both 'as_' and 'as' passed as arguments."
-            )
+            msg = "transform_calculate: both 'as_' and 'as' passed as arguments."
+            raise ValueError(msg)
         if as_ is not Undefined or calculate is not Undefined:
             dct = {"as": as_, "calculate": calculate}
             self = self._add_transform(core.CalculateTransform(**dct))  # type: ignore[arg-type]
@@ -1735,16 +1756,16 @@ def transform_calculate(
 
     def transform_density(
         self,
-        density: Union[str, core.FieldName],
-        as_: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        bandwidth: Union[float, UndefinedType] = Undefined,
-        counts: Union[bool, UndefinedType] = Undefined,
-        cumulative: Union[bool, UndefinedType] = Undefined,
-        extent: Union[List[float], UndefinedType] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        maxsteps: Union[int, UndefinedType] = Undefined,
-        minsteps: Union[int, UndefinedType] = Undefined,
-        steps: Union[int, UndefinedType] = Undefined,
+        density: str | FieldName,
+        as_: Optional[list[str | FieldName]] = Undefined,
+        bandwidth: Optional[float] = Undefined,
+        counts: Optional[bool] = Undefined,
+        cumulative: Optional[bool] = Undefined,
+        extent: Optional[list[float]] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
+        maxsteps: Optional[int] = Undefined,
+        minsteps: Optional[int] = Undefined,
+        steps: Optional[int] = Undefined,
     ) -> Self:
         """Add a :class:`DensityTransform` to the spec.
 
@@ -1758,7 +1779,7 @@ def transform_density(
         bandwidth : float
             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.
+            Scott's rule.
         counts : boolean
             A boolean flag indicating if the output values should be probability estimates
             (false) or smoothed counts (true).
@@ -1803,15 +1824,13 @@ def transform_density(
 
     def transform_impute(
         self,
-        impute: Union[str, core.FieldName],
-        key: Union[str, core.FieldName],
-        frame: Union[List[Optional[int]], UndefinedType] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        keyvals: Union[List[Any], core.ImputeSequence, UndefinedType] = Undefined,
-        method: Union[
-            Literal["value", "mean", "median", "max", "min"],
-            core.ImputeMethod,
-            UndefinedType,
+        impute: str | FieldName,
+        key: str | FieldName,
+        frame: Optional[list[int | None]] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
+        keyvals: Optional[list[Any] | ImputeSequence] = Undefined,
+        method: Optional[
+            Literal["value", "mean", "median", "max", "min"] | ImputeMethod
         ] = Undefined,
         value=Undefined,
     ) -> Self:
@@ -1877,10 +1896,8 @@ def transform_impute(
 
     def transform_joinaggregate(
         self,
-        joinaggregate: Union[
-            List[core.JoinAggregateFieldDef], UndefinedType
-        ] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
+        joinaggregate: Optional[list[JoinAggregateFieldDef]] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
         **kwargs: str,
     ) -> Self:
         """
@@ -1927,14 +1944,14 @@ def transform_joinaggregate(
                 "field": parsed.get("field", Undefined),
                 "op": parsed.get("aggregate", Undefined),
             }
-            assert not isinstance(joinaggregate, UndefinedType)  # For mypy
+            assert isinstance(joinaggregate, list)
             joinaggregate.append(core.JoinAggregateFieldDef(**dct))
         return self._add_transform(
             core.JoinAggregateTransform(joinaggregate=joinaggregate, groupby=groupby)
         )
 
     def transform_extent(
-        self, extent: Union[str, core.FieldName], param: Union[str, core.ParameterName]
+        self, extent: str | FieldName, param: str | ParameterName
     ) -> Self:
         """Add a :class:`ExtentTransform` to the spec.
 
@@ -1954,18 +1971,16 @@ def transform_extent(
         return self._add_transform(core.ExtentTransform(extent=extent, param=param))
 
     # TODO: Update docstring
+    # # E.g. {'not': alt.FieldRangePredicate(field='year', range=[1950, 1960])}
     def transform_filter(
         self,
-        filter: Union[
-            str,
-            core.Expr,
-            _expr_core.Expression,
-            core.Predicate,
-            Parameter,
-            core.PredicateComposition,
-            # E.g. {'not': alt.FieldRangePredicate(field='year', range=[1950, 1960])}
-            TypingDict[str, Union[core.Predicate, str, list, bool]],
-        ],
+        filter: str
+        | Expr
+        | Expression
+        | Predicate
+        | Parameter
+        | PredicateComposition
+        | dict[str, Predicate | str | list | bool],
         **kwargs,
     ) -> Self:
         """
@@ -1987,7 +2002,7 @@ def transform_filter(
             returns chart to allow for chaining
         """
         if isinstance(filter, Parameter):
-            new_filter: TypingDict[str, Union[bool, str]] = {"param": filter.name}
+            new_filter: dict[str, bool | str] = {"param": filter.name}
             if "empty" in kwargs:
                 new_filter["empty"] = kwargs.pop("empty")
             elif isinstance(filter.empty, bool):
@@ -1997,8 +2012,8 @@ def transform_filter(
 
     def transform_flatten(
         self,
-        flatten: List[Union[str, core.FieldName]],
-        as_: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
+        flatten: list[str | FieldName],
+        as_: Optional[list[str | FieldName]] = Undefined,
     ) -> Self:
         """Add a :class:`FlattenTransform` to the schema.
 
@@ -2029,8 +2044,8 @@ def transform_flatten(
 
     def transform_fold(
         self,
-        fold: List[Union[str, core.FieldName]],
-        as_: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
+        fold: list[str | FieldName],
+        as_: Optional[list[str | FieldName]] = Undefined,
     ) -> Self:
         """Add a :class:`FoldTransform` to the spec.
 
@@ -2056,11 +2071,11 @@ def transform_fold(
 
     def transform_loess(
         self,
-        on: Union[str, core.FieldName],
-        loess: Union[str, core.FieldName],
-        as_: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        bandwidth: Union[float, UndefinedType] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
+        on: str | FieldName,
+        loess: str | FieldName,
+        as_: Optional[list[str | FieldName]] = Undefined,
+        bandwidth: Optional[float] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
     ) -> Self:
         """Add a :class:`LoessTransform` to the spec.
 
@@ -2098,12 +2113,10 @@ def transform_loess(
 
     def transform_lookup(
         self,
-        lookup: Union[str, UndefinedType] = Undefined,
-        from_: Union[core.LookupData, core.LookupSelection, UndefinedType] = Undefined,
-        as_: Union[
-            Union[str, core.FieldName], List[Union[str, core.FieldName]], UndefinedType
-        ] = Undefined,
-        default: Union[str, UndefinedType] = Undefined,
+        lookup: Optional[str] = Undefined,
+        from_: Optional[LookupData | LookupSelection] = Undefined,
+        as_: Optional[str | FieldName | list[str | FieldName]] = Undefined,
+        default: Optional[str] = Undefined,
         **kwargs,
     ) -> Self:
         """Add a :class:`DataLookupTransform` or :class:`SelectionLookupTransform` to the chart
@@ -2139,15 +2152,13 @@ def transform_lookup(
         """
         if as_ is not Undefined:
             if "as" in kwargs:
-                raise ValueError(
-                    "transform_lookup: both 'as_' and 'as' passed as arguments."
-                )
+                msg = "transform_lookup: both 'as_' and 'as' passed as arguments."
+                raise ValueError(msg)
             kwargs["as"] = as_
         if from_ is not Undefined:
             if "from" in kwargs:
-                raise ValueError(
-                    "transform_lookup: both 'from_' and 'from' passed as arguments."
-                )
+                msg = "transform_lookup: both 'from_' and 'from' passed as arguments."
+                raise ValueError(msg)
             kwargs["from"] = from_
         kwargs["lookup"] = lookup
         kwargs["default"] = default
@@ -2155,11 +2166,11 @@ def transform_lookup(
 
     def transform_pivot(
         self,
-        pivot: Union[str, core.FieldName],
-        value: Union[str, core.FieldName],
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        limit: Union[int, UndefinedType] = Undefined,
-        op: Union[str, core.AggregateOp, UndefinedType] = Undefined,
+        pivot: str | FieldName,
+        value: str | FieldName,
+        groupby: Optional[list[str | FieldName]] = Undefined,
+        limit: Optional[int] = Undefined,
+        op: Optional[str | AggregateOp] = Undefined,
     ) -> Self:
         """Add a :class:`PivotTransform` to the chart.
 
@@ -2207,11 +2218,11 @@ def transform_pivot(
 
     def transform_quantile(
         self,
-        quantile: Union[str, core.FieldName],
-        as_: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        probs: Union[List[float], UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
+        quantile: str | FieldName,
+        as_: Optional[list[str | FieldName]] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
+        probs: Optional[list[float]] = Undefined,
+        step: Optional[float] = Undefined,
     ) -> Self:
         """Add a :class:`QuantileTransform` to the chart
 
@@ -2253,16 +2264,16 @@ def transform_quantile(
 
     def transform_regression(
         self,
-        on: Union[str, core.FieldName],
-        regression: Union[str, core.FieldName],
-        as_: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        extent: Union[List[float], UndefinedType] = Undefined,
-        groupby: Union[List[Union[str, core.FieldName]], UndefinedType] = Undefined,
-        method: Union[
-            Literal["linear", "log", "exp", "pow", "quad", "poly"], UndefinedType
+        on: str | FieldName,
+        regression: str | FieldName,
+        as_: Optional[list[str | FieldName]] = Undefined,
+        extent: Optional[list[float]] = Undefined,
+        groupby: Optional[list[str | FieldName]] = Undefined,
+        method: Optional[
+            Literal["linear", "log", "exp", "pow", "quad", "poly"]
         ] = Undefined,
-        order: Union[int, UndefinedType] = Undefined,
-        params: Union[bool, UndefinedType] = Undefined,
+        order: Optional[int] = Undefined,
+        params: Optional[bool] = Undefined,
     ) -> Self:
         """Add a :class:`RegressionTransform` to the chart.
 
@@ -2340,13 +2351,11 @@ def transform_sample(self, sample: int = 1000) -> Self:
 
     def transform_stack(
         self,
-        as_: Union[str, core.FieldName, List[str]],
-        stack: Union[str, core.FieldName],
-        groupby: List[Union[str, core.FieldName]],
-        offset: Union[
-            Literal["zero", "center", "normalize"], UndefinedType
-        ] = Undefined,
-        sort: Union[List[core.SortField], UndefinedType] = Undefined,
+        as_: str | FieldName | list[str],
+        stack: str | FieldName,
+        groupby: list[str | FieldName],
+        offset: Optional[Literal["zero", "center", "normalize"]] = Undefined,
+        sort: Optional[list[SortField]] = Undefined,
     ) -> Self:
         """
         Add a :class:`StackTransform` to the schema.
@@ -2384,9 +2393,9 @@ def transform_stack(
 
     def transform_timeunit(
         self,
-        as_: Union[str, core.FieldName, UndefinedType] = Undefined,
-        field: Union[str, core.FieldName, UndefinedType] = Undefined,
-        timeUnit: Union[str, core.TimeUnit, UndefinedType] = Undefined,
+        as_: Optional[str | FieldName] = Undefined,
+        field: Optional[str | FieldName] = Undefined,
+        timeUnit: Optional[str | TimeUnit] = Undefined,
         **kwargs: str,
     ) -> Self:
         """
@@ -2444,11 +2453,9 @@ def transform_timeunit(
         """
         if as_ is Undefined:
             as_ = kwargs.pop("as", Undefined)
-        else:
-            if "as" in kwargs:
-                raise ValueError(
-                    "transform_timeunit: both 'as_' and 'as' passed as arguments."
-                )
+        elif "as" in kwargs:
+            msg = "transform_timeunit: both 'as_' and 'as' passed as arguments."
+            raise ValueError(msg)
         if as_ is not Undefined:
             dct = {"as": as_, "timeUnit": timeUnit, "field": field}
             self = self._add_transform(core.TimeUnitTransform(**dct))  # type: ignore[arg-type]
@@ -2462,19 +2469,18 @@ def transform_timeunit(
             dct.pop("type", None)
             dct["as"] = as_
             if "timeUnit" not in dct:
-                raise ValueError("'{}' must include a valid timeUnit".format(shorthand))
+                msg = f"'{shorthand}' must include a valid timeUnit"
+                raise ValueError(msg)
             self = self._add_transform(core.TimeUnitTransform(**dct))  # type: ignore[arg-type]
         return self
 
     def transform_window(
         self,
-        window: Union[List[core.WindowFieldDef], UndefinedType] = Undefined,
-        frame: Union[List[Optional[int]], UndefinedType] = Undefined,
-        groupby: Union[List[str], UndefinedType] = Undefined,
-        ignorePeers: Union[bool, UndefinedType] = Undefined,
-        sort: Union[
-            List[Union[core.SortField, TypingDict[str, str]]], UndefinedType
-        ] = Undefined,
+        window: Optional[list[WindowFieldDef]] = Undefined,
+        frame: Optional[list[int | None]] = Undefined,
+        groupby: Optional[list[str]] = Undefined,
+        ignorePeers: Optional[bool] = Undefined,
+        sort: Optional[list[SortField | dict[str, str]]] = Undefined,
         **kwargs: str,
     ) -> Self:
         """Add a :class:`WindowTransform` to the schema
@@ -2558,7 +2564,7 @@ def transform_window(
                         parse_types=False,
                     )
                 )
-                assert not isinstance(window, UndefinedType)  # For mypy
+                assert isinstance(window, list)
                 # Ignore as core.WindowFieldDef has a Literal type hint with all options
                 window.append(core.WindowFieldDef(**kwds))  # type: ignore[arg-type]
 
@@ -2588,9 +2594,9 @@ def _repr_mimebundle_(self, include=None, exclude=None):
 
     def display(
         self,
-        renderer: Union[Literal["canvas", "svg"], UndefinedType] = Undefined,
-        theme: Union[str, UndefinedType] = Undefined,
-        actions: Union[bool, dict, UndefinedType] = Undefined,
+        renderer: Optional[Literal["canvas", "svg"]] = Undefined,
+        theme: Optional[str] = Undefined,
+        actions: Optional[bool | dict] = Undefined,
         **kwargs,
     ) -> None:
         """Display chart in Jupyter notebook or JupyterLab
@@ -2704,9 +2710,8 @@ def show(self) -> None:
     def _set_resolve(self, **kwargs):
         """Copy the chart and update the resolve property with kwargs"""
         if not hasattr(self, "resolve"):
-            raise ValueError(
-                "{} object has no attribute " "'resolve'".format(self.__class__)
-            )
+            msg = f"{self.__class__} object has no attribute " "'resolve'"
+            raise ValueError(msg)
         copy = self.copy(deep=["resolve"])
         if copy.resolve is Undefined:
             copy.resolve = core.Resolve()
@@ -2747,15 +2752,13 @@ def encode(self, *args, **kwargs) -> Self:
 
     def facet(
         self,
-        facet: Union[str, channels.Facet, UndefinedType] = Undefined,
-        row: Union[str, core.FacetFieldDef, channels.Row, UndefinedType] = Undefined,
-        column: Union[
-            str, core.FacetFieldDef, channels.Column, UndefinedType
-        ] = Undefined,
-        data: Union[ChartDataType, UndefinedType] = Undefined,
-        columns: Union[int, UndefinedType] = Undefined,
+        facet: Optional[str | Facet] = Undefined,
+        row: Optional[str | FacetFieldDef | Row] = Undefined,
+        column: Optional[str | FacetFieldDef | Column] = Undefined,
+        data: Optional[ChartDataType] = Undefined,
+        columns: Optional[int] = Undefined,
         **kwargs,
-    ) -> "FacetChart":
+    ) -> FacetChart:
         """Create a facet chart from the current chart.
 
         Faceted charts require data to be specified at the top level; if data
@@ -2788,18 +2791,18 @@ def facet(
         rowcol_specified = row is not Undefined or column is not Undefined
 
         if facet_specified and rowcol_specified:
-            raise ValueError(
-                "facet argument cannot be combined with row/column argument."
-            )
+            msg = "facet argument cannot be combined with row/column argument."
+            raise ValueError(msg)
 
         if data is Undefined:
             if self.data is Undefined:  # type: ignore[has-type]
-                raise ValueError(
+                msg = (
                     "Facet charts require data to be specified at the top level. "
                     "If you are trying to facet layered or concatenated charts, "
                     "ensure that the same data variable is passed to each chart "
                     "or specify the data inside the facet method instead."
                 )
+                raise ValueError(msg)
             # ignore type as copy comes from another class
             self = self.copy(deep=False)  # type: ignore[attr-defined]
             data, self.data = self.data, Undefined  # type: ignore[has-type]
@@ -2874,14 +2877,14 @@ class Chart(
 
     def __init__(
         self,
-        data: Union[ChartDataType, UndefinedType] = Undefined,
-        encoding: Union[core.FacetedEncoding, UndefinedType] = Undefined,
-        mark: Union[str, core.AnyMark, UndefinedType] = Undefined,
-        width: Union[int, str, dict, core.Step, UndefinedType] = Undefined,
-        height: Union[int, str, dict, core.Step, UndefinedType] = Undefined,
+        data: Optional[ChartDataType] = Undefined,
+        encoding: Optional[FacetedEncoding] = Undefined,
+        mark: Optional[str | AnyMark] = Undefined,
+        width: Optional[int | str | dict | Step] = Undefined,
+        height: Optional[int | str | dict | Step] = Undefined,
         **kwargs,
     ) -> None:
-        super(Chart, self).__init__(
+        super().__init__(
             # Data type hints won't match with what TopLevelUnitSpec expects
             # as there is some data processing happening when converting to
             # a VL spec
@@ -2901,7 +2904,7 @@ def _get_name(cls) -> str:
         return f"view_{cls._counter}"
 
     @classmethod
-    def from_dict(cls, dct: dict, validate: bool = True) -> core.SchemaBase:  # type: ignore[override]  # Not the same signature as SchemaBase.from_dict. Would ideally be aligned in the future
+    def from_dict(cls, dct: dict, validate: bool = True) -> SchemaBase:  # type: ignore[override]  # Not the same signature as SchemaBase.from_dict. Would ideally be aligned in the future
         """Construct class from a dictionary representation
 
         Parameters
@@ -2923,7 +2926,7 @@ def from_dict(cls, dct: dict, validate: bool = True) -> core.SchemaBase:  # type
         """
         for class_ in TopLevelMixin.__subclasses__():
             if class_ is Chart:
-                class_ = cast(TypingType[TopLevelMixin], super(Chart, cls))
+                class_ = cast(Any, super())
             try:
                 # TopLevelMixin classes don't necessarily have from_dict defined
                 # but all classes which are used here have due to how Altair is
@@ -2940,8 +2943,8 @@ def to_dict(
         validate: bool = True,
         *,
         format: str = "vega-lite",
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict:
         """Convert the chart to a dictionary suitable for JSON export
 
@@ -2988,10 +2991,8 @@ def to_dict(
         )
 
     def transformed_data(
-        self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> Optional[DataFrameLike]:
+        self, row_limit: int | None = None, exclude: Iterable[str] | None = None
+    ) -> DataFrameLike | None:
         """Evaluate a Chart's transforms
 
         Evaluate the data transforms associated with a Chart and return the
@@ -3033,7 +3034,7 @@ def add_selection(self, *params) -> Self:
         return self.add_params(*params)
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3061,7 +3062,7 @@ def interactive(
         return self.add_params(selection_interval(bind="scales", encodings=encodings))
 
 
-def _check_if_valid_subspec(spec: Union[dict, core.SchemaBase], classname: str) -> None:
+def _check_if_valid_subspec(spec: dict | SchemaBase, classname: str) -> None:
     """Check if the spec is a valid sub-spec.
 
     If it is not, then raise a ValueError
@@ -3072,7 +3073,8 @@ def _check_if_valid_subspec(spec: Union[dict, core.SchemaBase], classname: str)
     )
 
     if not isinstance(spec, (core.SchemaBase, dict)):
-        raise ValueError("Only chart objects can be used in {0}.".format(classname))
+        msg = f"Only chart objects can be used in {classname}."
+        raise ValueError(msg)
     for attr in TOPLEVEL_ONLY_KEYS:
         if isinstance(spec, core.SchemaBase):
             val = getattr(spec, attr, Undefined)
@@ -3082,7 +3084,7 @@ def _check_if_valid_subspec(spec: Union[dict, core.SchemaBase], classname: str)
             raise ValueError(err.format(attr, classname))
 
 
-def _check_if_can_be_layered(spec: Union[dict, core.SchemaBase]) -> None:
+def _check_if_can_be_layered(spec: dict | SchemaBase) -> None:
     """Check if the spec can be layered."""
 
     def _get(spec, attr):
@@ -3095,38 +3097,32 @@ def _get(spec, attr):
     if encoding is not Undefined:
         for channel in ["row", "column", "facet"]:
             if _get(encoding, channel) is not Undefined:
-                raise ValueError(
-                    "Faceted charts cannot be layered. Instead, layer the charts before faceting."
-                )
+                msg = "Faceted charts cannot be layered. Instead, layer the charts before faceting."
+                raise ValueError(msg)
     if isinstance(spec, (Chart, LayerChart)):
         return
 
     if not isinstance(spec, (core.SchemaBase, dict)):
-        raise ValueError("Only chart objects can be layered.")
+        msg = "Only chart objects can be layered."
+        raise ValueError(msg)
     if _get(spec, "facet") is not Undefined:
-        raise ValueError(
-            "Faceted charts cannot be layered. Instead, layer the charts before faceting."
-        )
+        msg = "Faceted charts cannot be layered. Instead, layer the charts before faceting."
+        raise ValueError(msg)
     if isinstance(spec, FacetChart) or _get(spec, "facet") is not Undefined:
-        raise ValueError(
-            "Faceted charts cannot be layered. Instead, layer the charts before faceting."
-        )
+        msg = "Faceted charts cannot be layered. Instead, layer the charts before faceting."
+        raise ValueError(msg)
     if isinstance(spec, RepeatChart) or _get(spec, "repeat") is not Undefined:
-        raise ValueError(
-            "Repeat charts cannot be layered. Instead, layer the charts before repeating."
-        )
+        msg = "Repeat charts cannot be layered. Instead, layer the charts before repeating."
+        raise ValueError(msg)
     if isinstance(spec, ConcatChart) or _get(spec, "concat") is not Undefined:
-        raise ValueError(
-            "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
-        )
+        msg = "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
+        raise ValueError(msg)
     if isinstance(spec, HConcatChart) or _get(spec, "hconcat") is not Undefined:
-        raise ValueError(
-            "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
-        )
+        msg = "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
+        raise ValueError(msg)
     if isinstance(spec, VConcatChart) or _get(spec, "vconcat") is not Undefined:
-        raise ValueError(
-            "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
-        )
+        msg = "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
+        raise ValueError(msg)
 
 
 class RepeatChart(TopLevelMixin, core.TopLevelRepeatSpec):
@@ -3166,7 +3162,7 @@ def __init__(
         spec = _spec_as_list[0]
         if isinstance(spec, (Chart, LayerChart)):
             params = _repeat_names(params, repeat, spec)
-        super(RepeatChart, self).__init__(
+        super().__init__(
             repeat=repeat,
             spec=spec,
             align=align,
@@ -3191,10 +3187,8 @@ def __init__(
         )
 
     def transformed_data(
-        self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> Optional[DataFrameLike]:
+        self, row_limit: int | None = None, exclude: Iterable[str] | None = None
+    ) -> DataFrameLike | None:
         """Evaluate a RepeatChart's transforms
 
         Evaluate the data transforms associated with a RepeatChart and return the
@@ -3212,12 +3206,11 @@ def transformed_data(
         NotImplementedError
             RepeatChart does not yet support transformed_data
         """
-        raise NotImplementedError(
-            "transformed_data is not yet implemented for RepeatChart"
-        )
+        msg = "transformed_data is not yet implemented for RepeatChart"
+        raise NotImplementedError(msg)
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3259,7 +3252,7 @@ def add_selection(self, *selections) -> Self:
 
 def repeat(
     repeater: Literal["row", "column", "repeat", "layer"] = "repeat",
-) -> core.RepeatRef:
+) -> RepeatRef:
     """Tie a channel to the row or column within a repeated chart
 
     The output of this should be passed to the ``field`` attribute of
@@ -3274,8 +3267,9 @@ def repeat(
     -------
     repeat : RepeatRef object
     """
-    if repeater not in ["row", "column", "repeat", "layer"]:
-        raise ValueError("repeater must be one of ['row', 'column', 'repeat', 'layer']")
+    if repeater not in {"row", "column", "repeat", "layer"}:
+        msg = "repeater must be one of ['row', 'column', 'repeat', 'layer']"
+        raise ValueError(msg)
     return core.RepeatRef(repeat=repeater)
 
 
@@ -3287,9 +3281,7 @@ def __init__(self, data=Undefined, concat=(), columns=Undefined, **kwargs):
         # TODO: move common data to top level?
         for spec in concat:
             _check_if_valid_subspec(spec, "ConcatChart")
-        super(ConcatChart, self).__init__(
-            data=data, concat=list(concat), columns=columns, **kwargs
-        )
+        super().__init__(data=data, concat=list(concat), columns=columns, **kwargs)
         self.data, self.concat = _combine_subchart_data(self.data, self.concat)
         self.params, self.concat = _combine_subchart_params(self.params, self.concat)
 
@@ -3302,16 +3294,14 @@ def __ior__(self, other: core.NonNormalizedSpec) -> Self:  # type: ignore[overri
         return self
 
     # Too difficult to fix override error
-    def __or__(self, other: core.NonNormalizedSpec) -> Self:  # type: ignore[override]
+    def __or__(self, other: NonNormalizedSpec) -> Self:  # type: ignore[override]
         copy = self.copy(deep=["concat"])
         copy |= other
         return copy
 
     def transformed_data(
-        self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> List[DataFrameLike]:
+        self, row_limit: int | None = None, exclude: Iterable[str] | None = None
+    ) -> list[DataFrameLike]:
         """Evaluate a ConcatChart's transforms
 
         Evaluate the data transforms associated with a ConcatChart and return the
@@ -3334,7 +3324,7 @@ def transformed_data(
         return transformed_data(self, row_limit=row_limit, exclude=exclude)
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3390,27 +3380,25 @@ def __init__(self, data=Undefined, hconcat=(), **kwargs):
         # TODO: move common data to top level?
         for spec in hconcat:
             _check_if_valid_subspec(spec, "HConcatChart")
-        super(HConcatChart, self).__init__(data=data, hconcat=list(hconcat), **kwargs)
+        super().__init__(data=data, hconcat=list(hconcat), **kwargs)
         self.data, self.hconcat = _combine_subchart_data(self.data, self.hconcat)
         self.params, self.hconcat = _combine_subchart_params(self.params, self.hconcat)
 
-    def __ior__(self, other: core.NonNormalizedSpec) -> Self:
+    def __ior__(self, other: NonNormalizedSpec) -> Self:
         _check_if_valid_subspec(other, "HConcatChart")
         self.hconcat.append(other)
         self.data, self.hconcat = _combine_subchart_data(self.data, self.hconcat)
         self.params, self.hconcat = _combine_subchart_params(self.params, self.hconcat)
         return self
 
-    def __or__(self, other: core.NonNormalizedSpec) -> Self:
+    def __or__(self, other: NonNormalizedSpec) -> Self:
         copy = self.copy(deep=["hconcat"])
         copy |= other
         return copy
 
     def transformed_data(
-        self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> List[DataFrameLike]:
+        self, row_limit: int | None = None, exclude: Iterable[str] | None = None
+    ) -> list[DataFrameLike]:
         """Evaluate a HConcatChart's transforms
 
         Evaluate the data transforms associated with a HConcatChart and return the
@@ -3433,7 +3421,7 @@ def transformed_data(
         return transformed_data(self, row_limit=row_limit, exclude=exclude)
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3489,27 +3477,27 @@ def __init__(self, data=Undefined, vconcat=(), **kwargs):
         # TODO: move common data to top level?
         for spec in vconcat:
             _check_if_valid_subspec(spec, "VConcatChart")
-        super(VConcatChart, self).__init__(data=data, vconcat=list(vconcat), **kwargs)
+        super().__init__(data=data, vconcat=list(vconcat), **kwargs)
         self.data, self.vconcat = _combine_subchart_data(self.data, self.vconcat)
         self.params, self.vconcat = _combine_subchart_params(self.params, self.vconcat)
 
-    def __iand__(self, other: core.NonNormalizedSpec) -> Self:
+    def __iand__(self, other: NonNormalizedSpec) -> Self:
         _check_if_valid_subspec(other, "VConcatChart")
         self.vconcat.append(other)
         self.data, self.vconcat = _combine_subchart_data(self.data, self.vconcat)
         self.params, self.vconcat = _combine_subchart_params(self.params, self.vconcat)
         return self
 
-    def __and__(self, other: core.NonNormalizedSpec) -> Self:
+    def __and__(self, other: NonNormalizedSpec) -> Self:
         copy = self.copy(deep=["vconcat"])
         copy &= other
         return copy
 
     def transformed_data(
         self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> List[DataFrameLike]:
+        row_limit: int | None = None,
+        exclude: Iterable[str] | None = None,
+    ) -> list[DataFrameLike]:
         """Evaluate a VConcatChart's transforms
 
         Evaluate the data transforms associated with a VConcatChart and return the
@@ -3532,7 +3520,7 @@ def transformed_data(
         return transformed_data(self, row_limit=row_limit, exclude=exclude)
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3590,7 +3578,7 @@ def __init__(self, data=Undefined, layer=(), **kwargs):
         for spec in layer:
             _check_if_valid_subspec(spec, "LayerChart")
             _check_if_can_be_layered(spec)
-        super(LayerChart, self).__init__(data=data, layer=list(layer), **kwargs)
+        super().__init__(data=data, layer=list(layer), **kwargs)
         self.data, self.layer = _combine_subchart_data(self.data, self.layer)
         # Currently (Vega-Lite 5.5) the same param can't occur on two layers
         self.layer = _remove_duplicate_params(self.layer)
@@ -3605,9 +3593,9 @@ def __init__(self, data=Undefined, layer=(), **kwargs):
 
     def transformed_data(
         self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> List[DataFrameLike]:
+        row_limit: int | None = None,
+        exclude: Iterable[str] | None = None,
+    ) -> list[DataFrameLike]:
         """Evaluate a LayerChart's transforms
 
         Evaluate the data transforms associated with a LayerChart and return the
@@ -3629,7 +3617,7 @@ def transformed_data(
 
         return transformed_data(self, row_limit=row_limit, exclude=exclude)
 
-    def __iadd__(self, other: Union[core.LayerSpec, core.UnitSpec]) -> Self:
+    def __iadd__(self, other: LayerSpec | UnitSpec) -> Self:
         _check_if_valid_subspec(other, "LayerChart")
         _check_if_can_be_layered(other)
         self.layer.append(other)
@@ -3637,19 +3625,19 @@ def __iadd__(self, other: Union[core.LayerSpec, core.UnitSpec]) -> Self:
         self.params, self.layer = _combine_subchart_params(self.params, self.layer)
         return self
 
-    def __add__(self, other: Union[core.LayerSpec, core.UnitSpec]) -> Self:
+    def __add__(self, other: LayerSpec | UnitSpec) -> Self:
         copy = self.copy(deep=["layer"])
         copy += other
         return copy
 
-    def add_layers(self, *layers: Union[core.LayerSpec, core.UnitSpec]) -> Self:
+    def add_layers(self, *layers: LayerSpec | UnitSpec) -> Self:
         copy = self.copy(deep=["layer"])
         for layer in layers:
             copy += layer
         return copy
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3670,9 +3658,8 @@ def interactive(
 
         """
         if not self.layer:
-            raise ValueError(
-                "LayerChart: cannot call interactive() until a " "layer is defined"
-            )
+            msg = "LayerChart: cannot call interactive() until a " "layer is defined"
+            raise ValueError(msg)
         copy = self.copy(deep=["layer"])
         copy.layer[0] = copy.layer[0].interactive(
             name=name, bind_x=bind_x, bind_y=bind_y
@@ -3716,15 +3703,11 @@ def __init__(
         _spec_as_list = [spec]
         params, _spec_as_list = _combine_subchart_params(params, _spec_as_list)
         spec = _spec_as_list[0]
-        super(FacetChart, self).__init__(
-            data=data, spec=spec, facet=facet, params=params, **kwargs
-        )
+        super().__init__(data=data, spec=spec, facet=facet, params=params, **kwargs)
 
     def transformed_data(
-        self,
-        row_limit: Optional[int] = None,
-        exclude: Optional[Iterable[str]] = None,
-    ) -> Optional[DataFrameLike]:
+        self, row_limit: int | None = None, exclude: Iterable[str] | None = None
+    ) -> DataFrameLike | None:
         """Evaluate a FacetChart's transforms
 
         Evaluate the data transforms associated with a FacetChart and return the
@@ -3747,7 +3730,7 @@ def transformed_data(
         return transformed_data(self, row_limit=row_limit, exclude=exclude)
 
     def interactive(
-        self, name: Optional[str] = None, bind_x: bool = True, bind_y: bool = True
+        self, name: str | None = None, bind_x: bool = True, bind_y: bool = True
     ) -> Self:
         """Make chart axes scales interactive
 
@@ -3787,7 +3770,7 @@ def add_selection(self, *selections) -> Self:
         return self.add_params(*selections)
 
 
-def topo_feature(url: str, feature: str, **kwargs) -> core.UrlData:
+def topo_feature(url: str, feature: str, **kwargs) -> UrlData:
     """A convenience function for extracting features from a topojson url
 
     Parameters
@@ -3826,11 +3809,10 @@ def remove_data(subchart):
         if subdata is not Undefined and all(c.data is subdata for c in subcharts):
             data = subdata
             subcharts = [remove_data(c) for c in subcharts]
-    else:
+    elif all(c.data is Undefined or c.data is data for c in subcharts):
         # Top level has data; subchart data must be either
         # undefined or identical to proceed.
-        if all(c.data is Undefined or c.data is data for c in subcharts):
-            subcharts = [remove_data(c) for c in subcharts]
+        subcharts = [remove_data(c) for c in subcharts]
 
     return data, subcharts
 
@@ -3847,10 +3829,7 @@ def _needs_name(subchart):
         return False
 
     # Variable parameters won't receive a views property.
-    if all(isinstance(p, core.VariableParameter) for p in subchart.params):
-        return False
-
-    return True
+    return not all(isinstance(p, core.VariableParameter) for p in subchart.params)
 
 
 # Convert SelectionParameters to TopLevelSelectionParameters with a views property.
@@ -4061,24 +4040,27 @@ def remove_prop(subchart, prop):
             elif all(v == values[0] for v in values[1:]):
                 output_dict[prop] = values[0]
             else:
-                raise ValueError(f"There are inconsistent values {values} for {prop}")
-        else:
+                msg = f"There are inconsistent values {values} for {prop}"
+                raise ValueError(msg)
+        elif all(
+            getattr(c, prop, Undefined) is Undefined or c[prop] == chart[prop]
+            for c in subcharts
+        ):
             # Top level has this prop; subchart must either not have the prop
             # or it must be Undefined or identical to proceed.
-            if all(
-                getattr(c, prop, Undefined) is Undefined or c[prop] == chart[prop]
-                for c in subcharts
-            ):
-                output_dict[prop] = chart[prop]
-            else:
-                raise ValueError(f"There are inconsistent values {values} for {prop}")
+            output_dict[prop] = chart[prop]
+        else:
+            msg = f"There are inconsistent values {values} for {prop}"
+            raise ValueError(msg)
         subcharts = [remove_prop(c, prop) for c in subcharts]
 
     return output_dict, subcharts
 
 
 @utils.use_signature(core.SequenceParams)
-def sequence(start, stop=None, step=Undefined, as_=Undefined, **kwds):
+def sequence(
+    start, stop=None, step=Undefined, as_=Undefined, **kwds
+) -> SequenceGenerator:
     """Sequence generator."""
     if stop is None:
         start, stop = 0, start
@@ -4087,17 +4069,14 @@ def sequence(start, stop=None, step=Undefined, as_=Undefined, **kwds):
 
 
 @utils.use_signature(core.GraticuleParams)
-def graticule(**kwds):
+def graticule(**kwds) -> GraticuleGenerator:
     """Graticule generator."""
-    if not kwds:
-        # graticule: True indicates default parameters
-        graticule = True
-    else:
-        graticule = core.GraticuleParams(**kwds)
+    # graticule: True indicates default parameters
+    graticule: Any = core.GraticuleParams(**kwds) if kwds else True
     return core.GraticuleGenerator(graticule=graticule)
 
 
-def sphere() -> core.SphereGenerator:
+def sphere() -> SphereGenerator:
     """Sphere generator."""
     return core.SphereGenerator(sphere=True)
 
@@ -4113,5 +4092,5 @@ def is_chart_type(obj: Any) -> TypeIs[ChartType]:
     """
     return isinstance(
         obj,
-        typing.get_args(ChartType),
-    )
+        (Chart, RepeatChart, ConcatChart, HConcatChart, VConcatChart, FacetChart, LayerChart)
+    )  # fmt: skip
diff --git a/altair/vegalite/v5/data.py b/altair/vegalite/v5/data.py
index 841c1d8bb..fbc339a46 100644
--- a/altair/vegalite/v5/data.py
+++ b/altair/vegalite/v5/data.py
@@ -38,6 +38,5 @@
     "to_csv",
     "to_json",
     "to_values",
-    "data_transformers",
     "vegafusion_data_transformer",
 )
diff --git a/altair/vegalite/v5/display.py b/altair/vegalite/v5/display.py
index b7901a7b7..0f066597c 100644
--- a/altair/vegalite/v5/display.py
+++ b/altair/vegalite/v5/display.py
@@ -1,5 +1,6 @@
-import os
-from typing import Dict
+from __future__ import annotations
+from pathlib import Path
+from typing import Final, TYPE_CHECKING
 
 from ...utils.mimebundle import spec_to_mimebundle
 from ..display import (
@@ -8,12 +9,13 @@
     json_renderer_base,
     RendererRegistry,
     HTMLRenderer,
-    DefaultRendererReturnType,
 )
 
 from .schema import SCHEMA_VERSION
 
-from typing import Final
+if TYPE_CHECKING:
+    from ..display import DefaultRendererReturnType
+
 
 VEGALITE_VERSION: Final = SCHEMA_VERSION.lstrip("v")
 VEGA_VERSION: Final = "5"
@@ -47,7 +49,7 @@
 
 renderers = RendererRegistry(entry_point_group=ENTRY_POINT_GROUP)
 
-here = os.path.dirname(os.path.realpath(__file__))
+here = str(Path(__file__).parent)
 
 
 def mimetype_renderer(spec: dict, **metadata) -> DefaultRendererReturnType:
@@ -58,7 +60,7 @@ def json_renderer(spec: dict, **metadata) -> DefaultRendererReturnType:
     return json_renderer_base(spec, DEFAULT_DISPLAY, **metadata)
 
 
-def png_renderer(spec: dict, **metadata) -> Dict[str, bytes]:
+def png_renderer(spec: dict, **metadata) -> dict[str, bytes]:
     # To get proper return value type, would need to write complex
     # overload signatures for spec_to_mimebundle based on `format`
     return spec_to_mimebundle(  # type: ignore[return-value]
@@ -72,10 +74,10 @@ def png_renderer(spec: dict, **metadata) -> Dict[str, bytes]:
     )
 
 
-def svg_renderer(spec: dict, **metadata) -> Dict[str, str]:
+def svg_renderer(spec: dict, **metadata) -> dict[str, str]:
     # To get proper return value type, would need to write complex
     # overload signatures for spec_to_mimebundle based on `format`
-    return spec_to_mimebundle(  # type: ignore[return-value]
+    return spec_to_mimebundle(
         spec,
         format="svg",
         mode="vega-lite",
@@ -108,7 +110,7 @@ def jupyter_renderer(spec: dict, **metadata):
 
 def browser_renderer(
     spec: dict, offline=False, using=None, port=0, **metadata
-) -> Dict[str, str]:
+) -> dict[str, str]:
     from altair.utils._show import open_html_in_browser
 
     if offline:
diff --git a/altair/vegalite/v5/schema/_typing.py b/altair/vegalite/v5/schema/_typing.py
new file mode 100644
index 000000000..67d12b6e5
--- /dev/null
+++ b/altair/vegalite/v5/schema/_typing.py
@@ -0,0 +1,897 @@
+# The contents of this file are automatically written by
+# tools/generate_schema_wrapper.py. Do not modify directly.
+
+
+from __future__ import annotations
+
+from typing import Literal
+
+from typing_extensions import TypeAlias
+
+AggregateOp_T: TypeAlias = Literal[
+    "argmax",
+    "argmin",
+    "average",
+    "count",
+    "distinct",
+    "max",
+    "mean",
+    "median",
+    "min",
+    "missing",
+    "product",
+    "q1",
+    "q3",
+    "ci0",
+    "ci1",
+    "stderr",
+    "stdev",
+    "stdevp",
+    "sum",
+    "valid",
+    "values",
+    "variance",
+    "variancep",
+    "exponential",
+    "exponentialb",
+]
+Align_T: TypeAlias = Literal["left", "center", "right"]
+AutosizeType_T: TypeAlias = Literal["pad", "none", "fit", "fit-x", "fit-y"]
+AxisOrient_T: TypeAlias = Literal["top", "bottom", "left", "right"]
+Baseline_T: TypeAlias = Literal["top", "middle", "bottom"]
+Blend_T: TypeAlias = Literal[
+    None,
+    "multiply",
+    "screen",
+    "overlay",
+    "darken",
+    "lighten",
+    "color-dodge",
+    "color-burn",
+    "hard-light",
+    "soft-light",
+    "difference",
+    "exclusion",
+    "hue",
+    "saturation",
+    "color",
+    "luminosity",
+]
+Categorical_T: TypeAlias = Literal[
+    "accent",
+    "category10",
+    "category20",
+    "category20b",
+    "category20c",
+    "dark2",
+    "paired",
+    "pastel1",
+    "pastel2",
+    "set1",
+    "set2",
+    "set3",
+    "tableau10",
+    "tableau20",
+]
+ColorName_T: TypeAlias = Literal[
+    "black",
+    "silver",
+    "gray",
+    "white",
+    "maroon",
+    "red",
+    "purple",
+    "fuchsia",
+    "green",
+    "lime",
+    "olive",
+    "yellow",
+    "navy",
+    "blue",
+    "teal",
+    "aqua",
+    "orange",
+    "aliceblue",
+    "antiquewhite",
+    "aquamarine",
+    "azure",
+    "beige",
+    "bisque",
+    "blanchedalmond",
+    "blueviolet",
+    "brown",
+    "burlywood",
+    "cadetblue",
+    "chartreuse",
+    "chocolate",
+    "coral",
+    "cornflowerblue",
+    "cornsilk",
+    "crimson",
+    "cyan",
+    "darkblue",
+    "darkcyan",
+    "darkgoldenrod",
+    "darkgray",
+    "darkgreen",
+    "darkgrey",
+    "darkkhaki",
+    "darkmagenta",
+    "darkolivegreen",
+    "darkorange",
+    "darkorchid",
+    "darkred",
+    "darksalmon",
+    "darkseagreen",
+    "darkslateblue",
+    "darkslategray",
+    "darkslategrey",
+    "darkturquoise",
+    "darkviolet",
+    "deeppink",
+    "deepskyblue",
+    "dimgray",
+    "dimgrey",
+    "dodgerblue",
+    "firebrick",
+    "floralwhite",
+    "forestgreen",
+    "gainsboro",
+    "ghostwhite",
+    "gold",
+    "goldenrod",
+    "greenyellow",
+    "grey",
+    "honeydew",
+    "hotpink",
+    "indianred",
+    "indigo",
+    "ivory",
+    "khaki",
+    "lavender",
+    "lavenderblush",
+    "lawngreen",
+    "lemonchiffon",
+    "lightblue",
+    "lightcoral",
+    "lightcyan",
+    "lightgoldenrodyellow",
+    "lightgray",
+    "lightgreen",
+    "lightgrey",
+    "lightpink",
+    "lightsalmon",
+    "lightseagreen",
+    "lightskyblue",
+    "lightslategray",
+    "lightslategrey",
+    "lightsteelblue",
+    "lightyellow",
+    "limegreen",
+    "linen",
+    "magenta",
+    "mediumaquamarine",
+    "mediumblue",
+    "mediumorchid",
+    "mediumpurple",
+    "mediumseagreen",
+    "mediumslateblue",
+    "mediumspringgreen",
+    "mediumturquoise",
+    "mediumvioletred",
+    "midnightblue",
+    "mintcream",
+    "mistyrose",
+    "moccasin",
+    "navajowhite",
+    "oldlace",
+    "olivedrab",
+    "orangered",
+    "orchid",
+    "palegoldenrod",
+    "palegreen",
+    "paleturquoise",
+    "palevioletred",
+    "papayawhip",
+    "peachpuff",
+    "peru",
+    "pink",
+    "plum",
+    "powderblue",
+    "rosybrown",
+    "royalblue",
+    "saddlebrown",
+    "salmon",
+    "sandybrown",
+    "seagreen",
+    "seashell",
+    "sienna",
+    "skyblue",
+    "slateblue",
+    "slategray",
+    "slategrey",
+    "snow",
+    "springgreen",
+    "steelblue",
+    "tan",
+    "thistle",
+    "tomato",
+    "turquoise",
+    "violet",
+    "wheat",
+    "whitesmoke",
+    "yellowgreen",
+    "rebeccapurple",
+]
+Cursor_T: TypeAlias = Literal[
+    "auto",
+    "default",
+    "none",
+    "context-menu",
+    "help",
+    "pointer",
+    "progress",
+    "wait",
+    "cell",
+    "crosshair",
+    "text",
+    "vertical-text",
+    "alias",
+    "copy",
+    "move",
+    "no-drop",
+    "not-allowed",
+    "e-resize",
+    "n-resize",
+    "ne-resize",
+    "nw-resize",
+    "s-resize",
+    "se-resize",
+    "sw-resize",
+    "w-resize",
+    "ew-resize",
+    "ns-resize",
+    "nesw-resize",
+    "nwse-resize",
+    "col-resize",
+    "row-resize",
+    "all-scroll",
+    "zoom-in",
+    "zoom-out",
+    "grab",
+    "grabbing",
+]
+Cyclical_T: TypeAlias = Literal["rainbow", "sinebow"]
+Diverging_T: TypeAlias = Literal[
+    "blueorange",
+    "blueorange-3",
+    "blueorange-4",
+    "blueorange-5",
+    "blueorange-6",
+    "blueorange-7",
+    "blueorange-8",
+    "blueorange-9",
+    "blueorange-10",
+    "blueorange-11",
+    "brownbluegreen",
+    "brownbluegreen-3",
+    "brownbluegreen-4",
+    "brownbluegreen-5",
+    "brownbluegreen-6",
+    "brownbluegreen-7",
+    "brownbluegreen-8",
+    "brownbluegreen-9",
+    "brownbluegreen-10",
+    "brownbluegreen-11",
+    "purplegreen",
+    "purplegreen-3",
+    "purplegreen-4",
+    "purplegreen-5",
+    "purplegreen-6",
+    "purplegreen-7",
+    "purplegreen-8",
+    "purplegreen-9",
+    "purplegreen-10",
+    "purplegreen-11",
+    "pinkyellowgreen",
+    "pinkyellowgreen-3",
+    "pinkyellowgreen-4",
+    "pinkyellowgreen-5",
+    "pinkyellowgreen-6",
+    "pinkyellowgreen-7",
+    "pinkyellowgreen-8",
+    "pinkyellowgreen-9",
+    "pinkyellowgreen-10",
+    "pinkyellowgreen-11",
+    "purpleorange",
+    "purpleorange-3",
+    "purpleorange-4",
+    "purpleorange-5",
+    "purpleorange-6",
+    "purpleorange-7",
+    "purpleorange-8",
+    "purpleorange-9",
+    "purpleorange-10",
+    "purpleorange-11",
+    "redblue",
+    "redblue-3",
+    "redblue-4",
+    "redblue-5",
+    "redblue-6",
+    "redblue-7",
+    "redblue-8",
+    "redblue-9",
+    "redblue-10",
+    "redblue-11",
+    "redgrey",
+    "redgrey-3",
+    "redgrey-4",
+    "redgrey-5",
+    "redgrey-6",
+    "redgrey-7",
+    "redgrey-8",
+    "redgrey-9",
+    "redgrey-10",
+    "redgrey-11",
+    "redyellowblue",
+    "redyellowblue-3",
+    "redyellowblue-4",
+    "redyellowblue-5",
+    "redyellowblue-6",
+    "redyellowblue-7",
+    "redyellowblue-8",
+    "redyellowblue-9",
+    "redyellowblue-10",
+    "redyellowblue-11",
+    "redyellowgreen",
+    "redyellowgreen-3",
+    "redyellowgreen-4",
+    "redyellowgreen-5",
+    "redyellowgreen-6",
+    "redyellowgreen-7",
+    "redyellowgreen-8",
+    "redyellowgreen-9",
+    "redyellowgreen-10",
+    "redyellowgreen-11",
+    "spectral",
+    "spectral-3",
+    "spectral-4",
+    "spectral-5",
+    "spectral-6",
+    "spectral-7",
+    "spectral-8",
+    "spectral-9",
+    "spectral-10",
+    "spectral-11",
+]
+ErrorBarExtent_T: TypeAlias = Literal["ci", "iqr", "stderr", "stdev"]
+FontWeight_T: TypeAlias = Literal[
+    "normal", "bold", "lighter", "bolder", 100, 200, 300, 400, 500, 600, 700, 800, 900
+]
+ImputeMethod_T: TypeAlias = Literal["value", "median", "max", "min", "mean"]
+Interpolate_T: TypeAlias = Literal[
+    "basis",
+    "basis-open",
+    "basis-closed",
+    "bundle",
+    "cardinal",
+    "cardinal-open",
+    "cardinal-closed",
+    "catmull-rom",
+    "linear",
+    "linear-closed",
+    "monotone",
+    "natural",
+    "step",
+    "step-before",
+    "step-after",
+]
+LayoutAlign_T: TypeAlias = Literal["all", "each", "none"]
+LegendOrient_T: TypeAlias = Literal[
+    "none",
+    "left",
+    "right",
+    "top",
+    "bottom",
+    "top-left",
+    "top-right",
+    "bottom-left",
+    "bottom-right",
+]
+LocalMultiTimeUnit_T: TypeAlias = Literal[
+    "yearquarter",
+    "yearquartermonth",
+    "yearmonth",
+    "yearmonthdate",
+    "yearmonthdatehours",
+    "yearmonthdatehoursminutes",
+    "yearmonthdatehoursminutesseconds",
+    "yearweek",
+    "yearweekday",
+    "yearweekdayhours",
+    "yearweekdayhoursminutes",
+    "yearweekdayhoursminutesseconds",
+    "yeardayofyear",
+    "quartermonth",
+    "monthdate",
+    "monthdatehours",
+    "monthdatehoursminutes",
+    "monthdatehoursminutesseconds",
+    "weekday",
+    "weekdayhours",
+    "weekdayhoursminutes",
+    "weekdayhoursminutesseconds",
+    "dayhours",
+    "dayhoursminutes",
+    "dayhoursminutesseconds",
+    "hoursminutes",
+    "hoursminutesseconds",
+    "minutesseconds",
+    "secondsmilliseconds",
+]
+LocalSingleTimeUnit_T: TypeAlias = Literal[
+    "year",
+    "quarter",
+    "month",
+    "week",
+    "day",
+    "dayofyear",
+    "date",
+    "hours",
+    "minutes",
+    "seconds",
+    "milliseconds",
+]
+MarkType_T: TypeAlias = Literal[
+    "arc",
+    "area",
+    "image",
+    "group",
+    "line",
+    "path",
+    "rect",
+    "rule",
+    "shape",
+    "symbol",
+    "text",
+    "trail",
+]
+Mark_T: TypeAlias = Literal[
+    "arc",
+    "area",
+    "bar",
+    "image",
+    "line",
+    "point",
+    "rect",
+    "rule",
+    "text",
+    "tick",
+    "trail",
+    "circle",
+    "square",
+    "geoshape",
+]
+NonArgAggregateOp_T: TypeAlias = Literal[
+    "average",
+    "count",
+    "distinct",
+    "max",
+    "mean",
+    "median",
+    "min",
+    "missing",
+    "product",
+    "q1",
+    "q3",
+    "ci0",
+    "ci1",
+    "stderr",
+    "stdev",
+    "stdevp",
+    "sum",
+    "valid",
+    "values",
+    "variance",
+    "variancep",
+    "exponential",
+    "exponentialb",
+]
+Orient_T: TypeAlias = Literal["left", "right", "top", "bottom"]
+Orientation_T: TypeAlias = Literal["horizontal", "vertical"]
+ProjectionType_T: TypeAlias = Literal[
+    "albers",
+    "albersUsa",
+    "azimuthalEqualArea",
+    "azimuthalEquidistant",
+    "conicConformal",
+    "conicEqualArea",
+    "conicEquidistant",
+    "equalEarth",
+    "equirectangular",
+    "gnomonic",
+    "identity",
+    "mercator",
+    "naturalEarth1",
+    "orthographic",
+    "stereographic",
+    "transverseMercator",
+]
+RangeEnum_T: TypeAlias = Literal[
+    "width", "height", "symbol", "category", "ordinal", "ramp", "diverging", "heatmap"
+]
+ResolveMode_T: TypeAlias = Literal["independent", "shared"]
+ScaleInterpolateEnum_T: TypeAlias = Literal[
+    "rgb", "lab", "hcl", "hsl", "hsl-long", "hcl-long", "cubehelix", "cubehelix-long"
+]
+ScaleType_T: TypeAlias = Literal[
+    "linear",
+    "log",
+    "pow",
+    "sqrt",
+    "symlog",
+    "identity",
+    "sequential",
+    "time",
+    "utc",
+    "quantile",
+    "quantize",
+    "threshold",
+    "bin-ordinal",
+    "ordinal",
+    "point",
+    "band",
+]
+SelectionResolution_T: TypeAlias = Literal["global", "union", "intersect"]
+SelectionType_T: TypeAlias = Literal["point", "interval"]
+SequentialMultiHue_T: TypeAlias = Literal[
+    "turbo",
+    "viridis",
+    "inferno",
+    "magma",
+    "plasma",
+    "cividis",
+    "bluegreen",
+    "bluegreen-3",
+    "bluegreen-4",
+    "bluegreen-5",
+    "bluegreen-6",
+    "bluegreen-7",
+    "bluegreen-8",
+    "bluegreen-9",
+    "bluepurple",
+    "bluepurple-3",
+    "bluepurple-4",
+    "bluepurple-5",
+    "bluepurple-6",
+    "bluepurple-7",
+    "bluepurple-8",
+    "bluepurple-9",
+    "goldgreen",
+    "goldgreen-3",
+    "goldgreen-4",
+    "goldgreen-5",
+    "goldgreen-6",
+    "goldgreen-7",
+    "goldgreen-8",
+    "goldgreen-9",
+    "goldorange",
+    "goldorange-3",
+    "goldorange-4",
+    "goldorange-5",
+    "goldorange-6",
+    "goldorange-7",
+    "goldorange-8",
+    "goldorange-9",
+    "goldred",
+    "goldred-3",
+    "goldred-4",
+    "goldred-5",
+    "goldred-6",
+    "goldred-7",
+    "goldred-8",
+    "goldred-9",
+    "greenblue",
+    "greenblue-3",
+    "greenblue-4",
+    "greenblue-5",
+    "greenblue-6",
+    "greenblue-7",
+    "greenblue-8",
+    "greenblue-9",
+    "orangered",
+    "orangered-3",
+    "orangered-4",
+    "orangered-5",
+    "orangered-6",
+    "orangered-7",
+    "orangered-8",
+    "orangered-9",
+    "purplebluegreen",
+    "purplebluegreen-3",
+    "purplebluegreen-4",
+    "purplebluegreen-5",
+    "purplebluegreen-6",
+    "purplebluegreen-7",
+    "purplebluegreen-8",
+    "purplebluegreen-9",
+    "purpleblue",
+    "purpleblue-3",
+    "purpleblue-4",
+    "purpleblue-5",
+    "purpleblue-6",
+    "purpleblue-7",
+    "purpleblue-8",
+    "purpleblue-9",
+    "purplered",
+    "purplered-3",
+    "purplered-4",
+    "purplered-5",
+    "purplered-6",
+    "purplered-7",
+    "purplered-8",
+    "purplered-9",
+    "redpurple",
+    "redpurple-3",
+    "redpurple-4",
+    "redpurple-5",
+    "redpurple-6",
+    "redpurple-7",
+    "redpurple-8",
+    "redpurple-9",
+    "yellowgreenblue",
+    "yellowgreenblue-3",
+    "yellowgreenblue-4",
+    "yellowgreenblue-5",
+    "yellowgreenblue-6",
+    "yellowgreenblue-7",
+    "yellowgreenblue-8",
+    "yellowgreenblue-9",
+    "yellowgreen",
+    "yellowgreen-3",
+    "yellowgreen-4",
+    "yellowgreen-5",
+    "yellowgreen-6",
+    "yellowgreen-7",
+    "yellowgreen-8",
+    "yellowgreen-9",
+    "yelloworangebrown",
+    "yelloworangebrown-3",
+    "yelloworangebrown-4",
+    "yelloworangebrown-5",
+    "yelloworangebrown-6",
+    "yelloworangebrown-7",
+    "yelloworangebrown-8",
+    "yelloworangebrown-9",
+    "yelloworangered",
+    "yelloworangered-3",
+    "yelloworangered-4",
+    "yelloworangered-5",
+    "yelloworangered-6",
+    "yelloworangered-7",
+    "yelloworangered-8",
+    "yelloworangered-9",
+    "darkblue",
+    "darkblue-3",
+    "darkblue-4",
+    "darkblue-5",
+    "darkblue-6",
+    "darkblue-7",
+    "darkblue-8",
+    "darkblue-9",
+    "darkgold",
+    "darkgold-3",
+    "darkgold-4",
+    "darkgold-5",
+    "darkgold-6",
+    "darkgold-7",
+    "darkgold-8",
+    "darkgold-9",
+    "darkgreen",
+    "darkgreen-3",
+    "darkgreen-4",
+    "darkgreen-5",
+    "darkgreen-6",
+    "darkgreen-7",
+    "darkgreen-8",
+    "darkgreen-9",
+    "darkmulti",
+    "darkmulti-3",
+    "darkmulti-4",
+    "darkmulti-5",
+    "darkmulti-6",
+    "darkmulti-7",
+    "darkmulti-8",
+    "darkmulti-9",
+    "darkred",
+    "darkred-3",
+    "darkred-4",
+    "darkred-5",
+    "darkred-6",
+    "darkred-7",
+    "darkred-8",
+    "darkred-9",
+    "lightgreyred",
+    "lightgreyred-3",
+    "lightgreyred-4",
+    "lightgreyred-5",
+    "lightgreyred-6",
+    "lightgreyred-7",
+    "lightgreyred-8",
+    "lightgreyred-9",
+    "lightgreyteal",
+    "lightgreyteal-3",
+    "lightgreyteal-4",
+    "lightgreyteal-5",
+    "lightgreyteal-6",
+    "lightgreyteal-7",
+    "lightgreyteal-8",
+    "lightgreyteal-9",
+    "lightmulti",
+    "lightmulti-3",
+    "lightmulti-4",
+    "lightmulti-5",
+    "lightmulti-6",
+    "lightmulti-7",
+    "lightmulti-8",
+    "lightmulti-9",
+    "lightorange",
+    "lightorange-3",
+    "lightorange-4",
+    "lightorange-5",
+    "lightorange-6",
+    "lightorange-7",
+    "lightorange-8",
+    "lightorange-9",
+    "lighttealblue",
+    "lighttealblue-3",
+    "lighttealblue-4",
+    "lighttealblue-5",
+    "lighttealblue-6",
+    "lighttealblue-7",
+    "lighttealblue-8",
+    "lighttealblue-9",
+]
+SequentialSingleHue_T: TypeAlias = Literal[
+    "blues",
+    "tealblues",
+    "teals",
+    "greens",
+    "browns",
+    "greys",
+    "purples",
+    "warmgreys",
+    "reds",
+    "oranges",
+]
+SingleDefUnitChannel_T: TypeAlias = Literal[
+    "x",
+    "y",
+    "xOffset",
+    "yOffset",
+    "x2",
+    "y2",
+    "longitude",
+    "latitude",
+    "longitude2",
+    "latitude2",
+    "theta",
+    "theta2",
+    "radius",
+    "radius2",
+    "color",
+    "fill",
+    "stroke",
+    "opacity",
+    "fillOpacity",
+    "strokeOpacity",
+    "strokeWidth",
+    "strokeDash",
+    "size",
+    "angle",
+    "shape",
+    "key",
+    "text",
+    "href",
+    "url",
+    "description",
+]
+SortByChannelDesc_T: TypeAlias = Literal[
+    "-x",
+    "-y",
+    "-color",
+    "-fill",
+    "-stroke",
+    "-strokeWidth",
+    "-size",
+    "-shape",
+    "-fillOpacity",
+    "-strokeOpacity",
+    "-opacity",
+    "-text",
+]
+SortByChannel_T: TypeAlias = Literal[
+    "x",
+    "y",
+    "color",
+    "fill",
+    "stroke",
+    "strokeWidth",
+    "size",
+    "shape",
+    "fillOpacity",
+    "strokeOpacity",
+    "opacity",
+    "text",
+]
+SortOrder_T: TypeAlias = Literal["ascending", "descending"]
+StackOffset_T: TypeAlias = Literal["zero", "center", "normalize"]
+StandardType_T: TypeAlias = Literal["quantitative", "ordinal", "temporal", "nominal"]
+StrokeCap_T: TypeAlias = Literal["butt", "round", "square"]
+StrokeJoin_T: TypeAlias = Literal["miter", "round", "bevel"]
+TextDirection_T: TypeAlias = Literal["ltr", "rtl"]
+TimeInterval_T: TypeAlias = Literal[
+    "millisecond", "second", "minute", "hour", "day", "week", "month", "year"
+]
+TitleAnchor_T: TypeAlias = Literal[None, "start", "middle", "end"]
+TitleFrame_T: TypeAlias = Literal["bounds", "group"]
+TitleOrient_T: TypeAlias = Literal["none", "left", "right", "top", "bottom"]
+TypeForShape_T: TypeAlias = Literal["nominal", "ordinal", "geojson"]
+Type_T: TypeAlias = Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"]
+UtcMultiTimeUnit_T: TypeAlias = Literal[
+    "utcyearquarter",
+    "utcyearquartermonth",
+    "utcyearmonth",
+    "utcyearmonthdate",
+    "utcyearmonthdatehours",
+    "utcyearmonthdatehoursminutes",
+    "utcyearmonthdatehoursminutesseconds",
+    "utcyearweek",
+    "utcyearweekday",
+    "utcyearweekdayhours",
+    "utcyearweekdayhoursminutes",
+    "utcyearweekdayhoursminutesseconds",
+    "utcyeardayofyear",
+    "utcquartermonth",
+    "utcmonthdate",
+    "utcmonthdatehours",
+    "utcmonthdatehoursminutes",
+    "utcmonthdatehoursminutesseconds",
+    "utcweekday",
+    "utcweeksdayhours",
+    "utcweekdayhoursminutes",
+    "utcweekdayhoursminutesseconds",
+    "utcdayhours",
+    "utcdayhoursminutes",
+    "utcdayhoursminutesseconds",
+    "utchoursminutes",
+    "utchoursminutesseconds",
+    "utcminutesseconds",
+    "utcsecondsmilliseconds",
+]
+UtcSingleTimeUnit_T: TypeAlias = Literal[
+    "utcyear",
+    "utcquarter",
+    "utcmonth",
+    "utcweek",
+    "utcday",
+    "utcdayofyear",
+    "utcdate",
+    "utchours",
+    "utcminutes",
+    "utcseconds",
+    "utcmilliseconds",
+]
+WindowOnlyOp_T: TypeAlias = Literal[
+    "row_number",
+    "rank",
+    "dense_rank",
+    "percent_rank",
+    "cume_dist",
+    "ntile",
+    "lag",
+    "lead",
+    "first_value",
+    "last_value",
+    "nth_value",
+]
diff --git a/altair/vegalite/v5/schema/channels.py b/altair/vegalite/v5/schema/channels.py
index 089a534a6..60d71f1a8 100644
--- a/altair/vegalite/v5/schema/channels.py
+++ b/altair/vegalite/v5/schema/channels.py
@@ -9,33 +9,40 @@
 # However, we need these overloads due to how the propertysetter works
 # mypy: disable-error-code="no-overload-impl, empty-body, misc"
 
-import sys
-from . import core
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal, Sequence, overload
+
 import pandas as pd
-from altair.utils.schemapi import Undefined, UndefinedType, with_property_setters
+
 from altair.utils import parse_shorthand
-from typing import Any, overload, Sequence, List, Literal, Union, Optional
-from typing import Dict as TypingDict
+from altair.utils.schemapi import Undefined, with_property_setters
+
+from . import core
+
+# ruff: noqa: F405
+if TYPE_CHECKING:
+    from altair import Parameter, SchemaBase
+    from altair.utils.schemapi import Optional
+
+    from ._typing import *  # noqa: F403
 
 
 class FieldChannelMixin:
     def to_dict(
         self,
         validate: bool = True,
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
-    ) -> Union[dict, List[dict]]:
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> dict | list[dict]:
         context = context or {}
         ignore = ignore or []
         shorthand = self._get("shorthand")  # type: ignore[attr-defined]
         field = self._get("field")  # type: ignore[attr-defined]
 
         if shorthand is not Undefined and field is not Undefined:
-            raise ValueError(
-                "{} specifies both shorthand={} and field={}. " "".format(
-                    self.__class__.__name__, shorthand, field
-                )
-            )
+            msg = f"{self.__class__.__name__} specifies both shorthand={shorthand} and field={field}. "
+            raise ValueError(msg)
 
         if isinstance(shorthand, (tuple, list)):
             # If given a list of shorthands, then transform it to a list of classes
@@ -61,38 +68,35 @@ def to_dict(
                 parsed.pop("type", None)
             elif not (type_in_shorthand or type_defined_explicitly):
                 if isinstance(context.get("data", None), pd.DataFrame):
-                    raise ValueError(
-                        'Unable to determine data type for the field "{}";'
+                    msg = (
+                        f'Unable to determine data type for the field "{shorthand}";'
                         " verify that the field name is not misspelled."
                         " If you are referencing a field from a transform,"
-                        " also confirm that the data type is specified correctly.".format(
-                            shorthand
-                        )
+                        " also confirm that the data type is specified correctly."
                     )
+                    raise ValueError(msg)
                 else:
-                    raise ValueError(
-                        "{} encoding field is specified without a type; "
+                    msg = (
+                        f"{shorthand} encoding field is specified without a type; "
                         "the type cannot be automatically inferred because "
                         "the data is not specified as a pandas.DataFrame."
-                        "".format(shorthand)
                     )
+                    raise ValueError(msg)
         else:
             # Shorthand is not a string; we pass the definition to field,
             # and do not do any parsing.
             parsed = {"field": shorthand}
         context["parsed_shorthand"] = parsed
 
-        return super(FieldChannelMixin, self).to_dict(
-            validate=validate, ignore=ignore, context=context
-        )
+        return super().to_dict(validate=validate, ignore=ignore, context=context)
 
 
 class ValueChannelMixin:
     def to_dict(
         self,
         validate: bool = True,
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict:
         context = context or {}
         ignore = ignore or []
@@ -114,16 +118,13 @@ class DatumChannelMixin:
     def to_dict(
         self,
         validate: bool = True,
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict:
         context = context or {}
         ignore = ignore or []
-        datum = self._get("datum", Undefined)  # type: ignore[attr-defined]
+        datum = self._get("datum", Undefined)  # type: ignore[attr-defined] # noqa
         copy = self  # don't copy unless we need to
-        if datum is not Undefined:
-            if isinstance(datum, core.SchemaBase):
-                pass
         return super(DatumChannelMixin, copy).to_dict(
             validate=validate, ignore=ignore, context=context
         )
@@ -386,1971 +387,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Angle": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Angle: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Angle": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Angle: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Angle": ...
+    def bandPosition(self, _: float, **kwds) -> Angle: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Angle": ...
+    def bin(self, _: bool, **kwds) -> Angle: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Angle": ...
+    def bin(self, _: None, **kwds) -> Angle: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "Angle": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> Angle: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Angle": ...
+    def field(self, _: str, **kwds) -> Angle: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Angle": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Angle": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Angle: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Angle: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Angle": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Angle": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Angle": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Angle": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Angle": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Angle": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Angle": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Angle: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Angle: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Angle: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Angle: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Angle: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Angle: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Angle: ...
 
     @overload
     def sort(
@@ -2370,7 +660,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def sort(
@@ -2390,76 +680,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Angle": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Angle: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Angle": ...
+    def sort(self, _: None, **kwds) -> Angle: ...
 
     @overload
     def timeUnit(
@@ -2478,7 +719,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def timeUnit(
@@ -2497,7 +738,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def timeUnit(
@@ -2534,7 +775,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def timeUnit(
@@ -2571,7 +812,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def timeUnit(
@@ -2593,7 +834,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def timeUnit(
@@ -2615,236 +856,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Angle": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Angle": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Angle": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Angle": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Angle: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Angle: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Angle: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Angle: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Angle": ...
+    ) -> Angle: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -2859,8 +935,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -2875,82 +951,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Angle, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -3082,68 +1089,58 @@ class AngleDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefnum
     _encoding_name = "angle"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "AngleDatum": ...
+    def bandPosition(self, _: float, **kwds) -> AngleDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "AngleDatum": ...
+    ) -> AngleDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "AngleDatum": ...
+    ) -> AngleDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "AngleDatum": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> AngleDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "AngleDatum": ...
+    def title(self, _: str, **kwds) -> AngleDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "AngleDatum": ...
+    def title(self, _: list[str], **kwds) -> AngleDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "AngleDatum": ...
+    def title(self, _: None, **kwds) -> AngleDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "AngleDatum": ...
+    ) -> AngleDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(AngleDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -3176,111 +1173,33 @@ class AngleValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -3295,8 +1214,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -3311,219 +1230,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "AngleValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> AngleValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "AngleValue": ...
+    ) -> AngleValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -3538,8 +1297,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -3554,146 +1313,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "AngleValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> AngleValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "AngleValue": ...
+    ) -> AngleValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "AngleValue": ...
+    ) -> AngleValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "AngleValue": ...
+    ) -> AngleValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "AngleValue": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> AngleValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(AngleValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -3956,1971 +1629,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Color": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Color: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Color": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Color: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Color": ...
+    def bandPosition(self, _: float, **kwds) -> Color: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Color": ...
+    def bin(self, _: bool, **kwds) -> Color: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Color": ...
+    def bin(self, _: None, **kwds) -> Color: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "Color": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> Color: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Color": ...
+    def field(self, _: str, **kwds) -> Color: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Color": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Color": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Color: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Color: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Color": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Color": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Color": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Color": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Color": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Color": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Color": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Color: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Color: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Color: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Color: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Color: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Color: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Color: ...
 
     @overload
     def sort(
@@ -5940,7 +1902,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def sort(
@@ -5960,76 +1922,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Color": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Color: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Color": ...
+    def sort(self, _: None, **kwds) -> Color: ...
 
     @overload
     def timeUnit(
@@ -6048,7 +1961,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def timeUnit(
@@ -6067,7 +1980,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def timeUnit(
@@ -6104,7 +2017,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def timeUnit(
@@ -6141,7 +2054,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def timeUnit(
@@ -6163,7 +2076,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def timeUnit(
@@ -6185,236 +2098,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Color": ...
+    ) -> Color: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Color": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Color": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Color": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Color": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Color: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Color: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Color: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Color: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Color": ...
+    ) -> Color: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -6429,8 +2177,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -6445,82 +2193,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Color, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -6654,68 +2333,58 @@ class ColorDatum(
     _encoding_name = "color"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "ColorDatum": ...
+    def bandPosition(self, _: float, **kwds) -> ColorDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ColorDatum": ...
+    ) -> ColorDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ColorDatum": ...
+    ) -> ColorDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "ColorDatum": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> ColorDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "ColorDatum": ...
+    def title(self, _: str, **kwds) -> ColorDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "ColorDatum": ...
+    def title(self, _: list[str], **kwds) -> ColorDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "ColorDatum": ...
+    def title(self, _: None, **kwds) -> ColorDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "ColorDatum": ...
+    ) -> ColorDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ColorDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -6749,111 +2418,33 @@ class ColorValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -6868,8 +2459,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -6884,219 +2475,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "ColorValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> ColorValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ColorValue": ...
+    ) -> ColorValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -7111,8 +2542,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -7127,146 +2558,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "ColorValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> ColorValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ColorValue": ...
+    ) -> ColorValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ColorValue": ...
+    ) -> ColorValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ColorValue": ...
+    ) -> ColorValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "ColorValue": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> ColorValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(ColorValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -7512,577 +2857,141 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Column": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Column: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Column": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Column: ...
 
     @overload
-    def align(self, _: Literal["all", "each", "none"], **kwds) -> "Column": ...
+    def align(self, _: Literal["all", "each", "none"], **kwds) -> Column: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Column": ...
+    def bandPosition(self, _: float, **kwds) -> Column: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Column": ...
+    def bin(self, _: bool, **kwds) -> Column: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Column": ...
+    def bin(self, _: None, **kwds) -> Column: ...
 
     @overload
-    def center(self, _: bool, **kwds) -> "Column": ...
+    def center(self, _: bool, **kwds) -> Column: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Column": ...
+    def field(self, _: str, **kwds) -> Column: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def header(
         self,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAnchor: Union[
-            core.SchemaBase, Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        labelAngle: Union[float, UndefinedType] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOrient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            core.SchemaBase, Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        titleAngle: Union[float, UndefinedType] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Column": ...
-
-    @overload
-    def header(self, _: None, **kwds) -> "Column": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Column": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Column": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Column": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Column": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Column": ...
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        labelAngle: Optional[float] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        orient: Optional[Orient_T | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        titleAngle: Optional[float] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Column: ...
+
+    @overload
+    def header(self, _: None, **kwds) -> Column: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Column: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Column: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Column: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Column: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Column: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Column": ...
-
-    @overload
-    def sort(self, _: None, **kwds) -> "Column": ...
-
-    @overload
-    def spacing(self, _: float, **kwds) -> "Column": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Column: ...
+
+    @overload
+    def sort(self, _: None, **kwds) -> Column: ...
+
+    @overload
+    def spacing(self, _: float, **kwds) -> Column: ...
 
     @overload
     def timeUnit(
@@ -8101,7 +3010,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def timeUnit(
@@ -8120,7 +3029,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def timeUnit(
@@ -8157,7 +3066,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def timeUnit(
@@ -8194,7 +3103,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def timeUnit(
@@ -8216,7 +3125,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def timeUnit(
@@ -8238,209 +3147,68 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Column": ...
+    ) -> Column: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Column": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Column": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Column": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Column": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Column: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Column: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Column: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Column: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Column": ...
+    ) -> Column: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            core.SchemaBase, Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        header: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        align: Optional[SchemaBase | LayoutAlign_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        center: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        header: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        spacing: Optional[float] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -8455,8 +3223,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -8471,82 +3239,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Column, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             align=align,
@@ -8794,94 +3493,86 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Description": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Description: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Description": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Description: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Description": ...
+    def bandPosition(self, _: float, **kwds) -> Description: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Description": ...
+    def bin(self, _: bool, **kwds) -> Description: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Description": ...
+    def bin(self, _: str, **kwds) -> Description: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Description": ...
+    def bin(self, _: None, **kwds) -> Description: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringExprRef], **kwds
-    ) -> "Description": ...
+        self, _: list[core.ConditionalValueDefstringExprRef], **kwds
+    ) -> Description: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Description": ...
+    def field(self, _: str, **kwds) -> Description: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
-    def format(self, _: str, **kwds) -> "Description": ...
+    def format(self, _: str, **kwds) -> Description: ...
 
     @overload
-    def format(self, _: dict, **kwds) -> "Description": ...
+    def format(self, _: dict, **kwds) -> Description: ...
 
     @overload
-    def formatType(self, _: str, **kwds) -> "Description": ...
+    def formatType(self, _: str, **kwds) -> Description: ...
 
     @overload
     def timeUnit(
@@ -8900,7 +3591,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def timeUnit(
@@ -8919,7 +3610,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def timeUnit(
@@ -8956,7 +3647,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def timeUnit(
@@ -8993,7 +3684,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def timeUnit(
@@ -9015,7 +3706,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def timeUnit(
@@ -9037,197 +3728,59 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Description": ...
+    ) -> Description: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Description": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Description": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Description": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Description": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Description: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Description: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Description: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Description: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Description": ...
+    ) -> Description: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -9242,8 +3795,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -9258,82 +3811,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Description, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -9370,111 +3854,33 @@ class DescriptionValue(ValueChannelMixin, core.StringValueDefWithCondition):
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -9489,8 +3895,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -9505,219 +3911,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "DescriptionValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> DescriptionValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "DescriptionValue": ...
+    ) -> DescriptionValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -9732,8 +3978,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -9748,146 +3994,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "DescriptionValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> DescriptionValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "DescriptionValue": ...
+    ) -> DescriptionValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "DescriptionValue": ...
+    ) -> DescriptionValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "DescriptionValue": ...
+    ) -> DescriptionValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "DescriptionValue": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> DescriptionValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(DescriptionValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -10080,59 +4240,55 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Detail": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Detail: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Detail": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Detail: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Detail": ...
+    def bandPosition(self, _: float, **kwds) -> Detail: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Detail": ...
+    def bin(self, _: bool, **kwds) -> Detail: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Detail": ...
+    def bin(self, _: str, **kwds) -> Detail: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Detail": ...
+    def bin(self, _: None, **kwds) -> Detail: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Detail": ...
+    def field(self, _: str, **kwds) -> Detail: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
@@ -10151,7 +4307,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
@@ -10170,7 +4326,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
@@ -10207,7 +4363,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
@@ -10244,7 +4400,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
@@ -10266,7 +4422,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
@@ -10288,192 +4444,54 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Detail": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Detail": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Detail": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Detail": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Detail: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Detail: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Detail: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Detail: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Detail": ...
+    ) -> Detail: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -10488,8 +4506,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -10504,82 +4522,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Detail, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -10873,611 +4822,171 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Facet": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Facet: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Facet": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Facet: ...
 
     @overload
-    def align(self, _: Literal["all", "each", "none"], **kwds) -> "Facet": ...
+    def align(self, _: Literal["all", "each", "none"], **kwds) -> Facet: ...
 
     @overload
     def align(
         self,
-        column: Union[
-            core.SchemaBase, Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        row: Union[
-            core.SchemaBase, Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
+        column: Optional[SchemaBase | LayoutAlign_T] = Undefined,
+        row: Optional[SchemaBase | LayoutAlign_T] = Undefined,
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Facet": ...
+    def bandPosition(self, _: float, **kwds) -> Facet: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Facet": ...
+    def bin(self, _: bool, **kwds) -> Facet: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Facet": ...
+    def bin(self, _: None, **kwds) -> Facet: ...
 
     @overload
-    def bounds(self, _: Literal["full", "flush"], **kwds) -> "Facet": ...
+    def bounds(self, _: Literal["full", "flush"], **kwds) -> Facet: ...
 
     @overload
-    def center(self, _: bool, **kwds) -> "Facet": ...
+    def center(self, _: bool, **kwds) -> Facet: ...
 
     @overload
     def center(
         self,
-        column: Union[bool, UndefinedType] = Undefined,
-        row: Union[bool, UndefinedType] = Undefined,
+        column: Optional[bool] = Undefined,
+        row: Optional[bool] = Undefined,
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
-    def columns(self, _: float, **kwds) -> "Facet": ...
+    def columns(self, _: float, **kwds) -> Facet: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Facet": ...
+    def field(self, _: str, **kwds) -> Facet: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def header(
         self,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAnchor: Union[
-            core.SchemaBase, Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        labelAngle: Union[float, UndefinedType] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOrient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            core.SchemaBase, Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        titleAngle: Union[float, UndefinedType] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Facet": ...
-
-    @overload
-    def header(self, _: None, **kwds) -> "Facet": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Facet": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Facet": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Facet": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Facet": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Facet": ...
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        labelAngle: Optional[float] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        orient: Optional[Orient_T | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        titleAngle: Optional[float] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Facet: ...
+
+    @overload
+    def header(self, _: None, **kwds) -> Facet: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Facet: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Facet: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Facet: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Facet: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Facet: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Facet": ...
-
-    @overload
-    def sort(self, _: None, **kwds) -> "Facet": ...
-
-    @overload
-    def spacing(self, _: float, **kwds) -> "Facet": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Facet: ...
+
+    @overload
+    def sort(self, _: None, **kwds) -> Facet: ...
+
+    @overload
+    def spacing(self, _: float, **kwds) -> Facet: ...
 
     @overload
     def spacing(
         self,
-        column: Union[float, UndefinedType] = Undefined,
-        row: Union[float, UndefinedType] = Undefined,
+        column: Optional[float] = Undefined,
+        row: Optional[float] = Undefined,
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
@@ -11496,7 +5005,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
@@ -11515,7 +5024,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
@@ -11552,7 +5061,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
@@ -11589,7 +5098,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
@@ -11611,7 +5120,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
@@ -11633,211 +5142,70 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Facet": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Facet": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Facet": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Facet": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Facet: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Facet: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Facet: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Facet: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Facet": ...
+    ) -> Facet: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            dict, core.SchemaBase, Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        header: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        spacing: Union[dict, float, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        header: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -11852,8 +5220,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -11868,82 +5236,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Facet, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             align=align,
@@ -12223,1971 +5522,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Fill": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Fill: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Fill": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Fill: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Fill": ...
+    def bandPosition(self, _: float, **kwds) -> Fill: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Fill": ...
+    def bin(self, _: bool, **kwds) -> Fill: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Fill": ...
+    def bin(self, _: None, **kwds) -> Fill: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "Fill": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> Fill: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Fill": ...
+    def field(self, _: str, **kwds) -> Fill: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Fill": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Fill": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Fill: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Fill: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Fill": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Fill": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Fill": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Fill": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Fill": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Fill": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Fill": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Fill: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Fill: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Fill: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Fill: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Fill: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Fill: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Fill: ...
 
     @overload
     def sort(
@@ -14207,7 +5795,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def sort(
@@ -14227,76 +5815,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Fill": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Fill: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Fill": ...
+    def sort(self, _: None, **kwds) -> Fill: ...
 
     @overload
     def timeUnit(
@@ -14315,7 +5854,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def timeUnit(
@@ -14334,7 +5873,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def timeUnit(
@@ -14371,7 +5910,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def timeUnit(
@@ -14408,7 +5947,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def timeUnit(
@@ -14430,7 +5969,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def timeUnit(
@@ -14452,236 +5991,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Fill": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Fill": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Fill": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Fill": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Fill: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Fill: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Fill: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Fill: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Fill": ...
+    ) -> Fill: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -14696,8 +6070,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -14712,82 +6086,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Fill, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -14921,68 +6226,58 @@ class FillDatum(
     _encoding_name = "fill"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "FillDatum": ...
+    def bandPosition(self, _: float, **kwds) -> FillDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillDatum": ...
+    ) -> FillDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillDatum": ...
+    ) -> FillDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "FillDatum": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> FillDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "FillDatum": ...
+    def title(self, _: str, **kwds) -> FillDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "FillDatum": ...
+    def title(self, _: list[str], **kwds) -> FillDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "FillDatum": ...
+    def title(self, _: None, **kwds) -> FillDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "FillDatum": ...
+    ) -> FillDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FillDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -15016,111 +6311,33 @@ class FillValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -15135,8 +6352,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -15151,219 +6368,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "FillValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> FillValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillValue": ...
+    ) -> FillValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -15378,8 +6435,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -15394,146 +6451,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "FillValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> FillValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillValue": ...
+    ) -> FillValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillValue": ...
+    ) -> FillValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillValue": ...
+    ) -> FillValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "FillValue": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> FillValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(FillValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -15795,1971 +6766,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "FillOpacity": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> FillOpacity: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "FillOpacity": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> FillOpacity: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "FillOpacity": ...
+    def bandPosition(self, _: float, **kwds) -> FillOpacity: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "FillOpacity": ...
+    def bin(self, _: bool, **kwds) -> FillOpacity: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "FillOpacity": ...
+    def bin(self, _: None, **kwds) -> FillOpacity: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "FillOpacity": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> FillOpacity: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "FillOpacity": ...
+    def field(self, _: str, **kwds) -> FillOpacity: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "FillOpacity": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "FillOpacity": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> FillOpacity: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> FillOpacity: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "FillOpacity": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "FillOpacity": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "FillOpacity": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "FillOpacity": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "FillOpacity": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "FillOpacity": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "FillOpacity": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> FillOpacity: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> FillOpacity: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> FillOpacity: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> FillOpacity: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> FillOpacity: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> FillOpacity: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> FillOpacity: ...
 
     @overload
     def sort(
@@ -17779,7 +7039,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def sort(
@@ -17799,76 +7059,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "FillOpacity": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> FillOpacity: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "FillOpacity": ...
+    def sort(self, _: None, **kwds) -> FillOpacity: ...
 
     @overload
     def timeUnit(
@@ -17887,7 +7098,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def timeUnit(
@@ -17906,7 +7117,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def timeUnit(
@@ -17943,7 +7154,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def timeUnit(
@@ -17980,7 +7191,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def timeUnit(
@@ -18002,7 +7213,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def timeUnit(
@@ -18024,236 +7235,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "FillOpacity": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "FillOpacity": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "FillOpacity": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "FillOpacity": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> FillOpacity: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> FillOpacity: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> FillOpacity: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> FillOpacity: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "FillOpacity": ...
+    ) -> FillOpacity: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -18268,8 +7314,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -18284,82 +7330,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FillOpacity, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -18493,68 +7470,58 @@ class FillOpacityDatum(
     _encoding_name = "fillOpacity"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "FillOpacityDatum": ...
+    def bandPosition(self, _: float, **kwds) -> FillOpacityDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacityDatum": ...
+    ) -> FillOpacityDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacityDatum": ...
+    ) -> FillOpacityDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "FillOpacityDatum": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> FillOpacityDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "FillOpacityDatum": ...
+    def title(self, _: str, **kwds) -> FillOpacityDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "FillOpacityDatum": ...
+    def title(self, _: list[str], **kwds) -> FillOpacityDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "FillOpacityDatum": ...
+    def title(self, _: None, **kwds) -> FillOpacityDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "FillOpacityDatum": ...
+    ) -> FillOpacityDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FillOpacityDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -18587,111 +7554,33 @@ class FillOpacityValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -18706,8 +7595,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -18722,219 +7611,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "FillOpacityValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> FillOpacityValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacityValue": ...
+    ) -> FillOpacityValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -18949,8 +7678,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -18965,146 +7694,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "FillOpacityValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> FillOpacityValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacityValue": ...
+    ) -> FillOpacityValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacityValue": ...
+    ) -> FillOpacityValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "FillOpacityValue": ...
+    ) -> FillOpacityValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "FillOpacityValue": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> FillOpacityValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(FillOpacityValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -19337,94 +7980,86 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Href": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Href: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Href": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Href: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Href": ...
+    def bandPosition(self, _: float, **kwds) -> Href: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Href": ...
+    def bin(self, _: bool, **kwds) -> Href: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Href": ...
+    def bin(self, _: str, **kwds) -> Href: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Href": ...
+    def bin(self, _: None, **kwds) -> Href: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringExprRef], **kwds
-    ) -> "Href": ...
+        self, _: list[core.ConditionalValueDefstringExprRef], **kwds
+    ) -> Href: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Href": ...
+    def field(self, _: str, **kwds) -> Href: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
-    def format(self, _: str, **kwds) -> "Href": ...
+    def format(self, _: str, **kwds) -> Href: ...
 
     @overload
-    def format(self, _: dict, **kwds) -> "Href": ...
+    def format(self, _: dict, **kwds) -> Href: ...
 
     @overload
-    def formatType(self, _: str, **kwds) -> "Href": ...
+    def formatType(self, _: str, **kwds) -> Href: ...
 
     @overload
     def timeUnit(
@@ -19443,7 +8078,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def timeUnit(
@@ -19462,7 +8097,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def timeUnit(
@@ -19499,7 +8134,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def timeUnit(
@@ -19536,7 +8171,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def timeUnit(
@@ -19558,7 +8193,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def timeUnit(
@@ -19580,197 +8215,59 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Href": ...
+    ) -> Href: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Href": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Href": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Href": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Href": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Href: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Href: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Href: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Href: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Href": ...
+    ) -> Href: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -19785,8 +8282,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -19801,82 +8298,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Href, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -19913,111 +8341,33 @@ class HrefValue(ValueChannelMixin, core.StringValueDefWithCondition):
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -20032,8 +8382,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -20048,219 +8398,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "HrefValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> HrefValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "HrefValue": ...
+    ) -> HrefValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -20275,8 +8465,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -20291,146 +8481,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "HrefValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> HrefValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "HrefValue": ...
+    ) -> HrefValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "HrefValue": ...
+    ) -> HrefValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "HrefValue": ...
+    ) -> HrefValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "HrefValue": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> HrefValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(HrefValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -20623,59 +8727,55 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Key": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Key: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Key": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Key: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Key": ...
+    def bandPosition(self, _: float, **kwds) -> Key: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Key": ...
+    def bin(self, _: bool, **kwds) -> Key: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Key": ...
+    def bin(self, _: str, **kwds) -> Key: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Key": ...
+    def bin(self, _: None, **kwds) -> Key: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Key": ...
+    def field(self, _: str, **kwds) -> Key: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
@@ -20694,7 +8794,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
@@ -20713,7 +8813,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
@@ -20750,7 +8850,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
@@ -20787,7 +8887,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
@@ -20809,7 +8909,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
@@ -20831,192 +8931,54 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Key": ...
+    ) -> Key: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Key": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Key": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Key": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Key": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Key: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Key: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Key: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Key: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Key": ...
+    ) -> Key: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -21031,8 +8993,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -21047,82 +9009,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Key, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -21324,35 +9217,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Latitude": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Latitude: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Latitude": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Latitude: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Latitude": ...
+    def bandPosition(self, _: float, **kwds) -> Latitude: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Latitude": ...
+    def bin(self, _: None, **kwds) -> Latitude: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Latitude": ...
+    def field(self, _: str, **kwds) -> Latitude: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
@@ -21371,7 +9262,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
@@ -21390,7 +9281,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
@@ -21427,7 +9318,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
@@ -21464,7 +9355,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
@@ -21486,7 +9377,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
@@ -21508,190 +9399,52 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Latitude": ...
+    ) -> Latitude: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Latitude": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Latitude": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Latitude": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Latitude": ...
-
-    @overload
-    def type(self, _: str, **kwds) -> "Latitude": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Latitude: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Latitude: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Latitude: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Latitude: ...
+
+    @overload
+    def type(self, _: str, **kwds) -> Latitude: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -21706,8 +9459,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -21722,78 +9475,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[str] = Undefined,
         **kwds,
     ):
-        super(Latitude, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -21914,39 +9602,33 @@ class LatitudeDatum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "latitude"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "LatitudeDatum": ...
+    def bandPosition(self, _: float, **kwds) -> LatitudeDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "LatitudeDatum": ...
+    def title(self, _: str, **kwds) -> LatitudeDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "LatitudeDatum": ...
+    def title(self, _: list[str], **kwds) -> LatitudeDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "LatitudeDatum": ...
+    def title(self, _: None, **kwds) -> LatitudeDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "LatitudeDatum": ...
+    ) -> LatitudeDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(LatitudeDatum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -22073,35 +9755,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Latitude2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Latitude2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Latitude2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Latitude2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Latitude2": ...
+    def bandPosition(self, _: float, **kwds) -> Latitude2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Latitude2": ...
+    def bin(self, _: None, **kwds) -> Latitude2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Latitude2": ...
+    def field(self, _: str, **kwds) -> Latitude2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
@@ -22120,7 +9800,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
@@ -22139,7 +9819,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
@@ -22176,7 +9856,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
@@ -22213,7 +9893,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
@@ -22235,7 +9915,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
@@ -22257,187 +9937,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Latitude2": ...
+    ) -> Latitude2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Latitude2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Latitude2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Latitude2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Latitude2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Latitude2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Latitude2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Latitude2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Latitude2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -22452,8 +9994,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -22468,77 +10010,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(Latitude2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -22658,39 +10135,33 @@ class Latitude2Datum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "latitude2"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Latitude2Datum": ...
+    def bandPosition(self, _: float, **kwds) -> Latitude2Datum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "Latitude2Datum": ...
+    def title(self, _: str, **kwds) -> Latitude2Datum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "Latitude2Datum": ...
+    def title(self, _: list[str], **kwds) -> Latitude2Datum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "Latitude2Datum": ...
+    def title(self, _: None, **kwds) -> Latitude2Datum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "Latitude2Datum": ...
+    ) -> Latitude2Datum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Latitude2Datum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -22714,7 +10185,7 @@ class Latitude2Value(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "latitude2"
 
     def __init__(self, value, **kwds):
-        super(Latitude2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -22906,35 +10377,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Longitude": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Longitude: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Longitude": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Longitude: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Longitude": ...
+    def bandPosition(self, _: float, **kwds) -> Longitude: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Longitude": ...
+    def bin(self, _: None, **kwds) -> Longitude: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Longitude": ...
+    def field(self, _: str, **kwds) -> Longitude: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
@@ -22953,7 +10422,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
@@ -22972,7 +10441,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
@@ -23009,7 +10478,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
@@ -23046,7 +10515,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
@@ -23068,7 +10537,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
@@ -23090,190 +10559,52 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Longitude": ...
+    ) -> Longitude: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Longitude": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Longitude": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Longitude": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Longitude": ...
-
-    @overload
-    def type(self, _: str, **kwds) -> "Longitude": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Longitude: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Longitude: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Longitude: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Longitude: ...
+
+    @overload
+    def type(self, _: str, **kwds) -> Longitude: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -23288,8 +10619,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -23304,78 +10635,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[str] = Undefined,
         **kwds,
     ):
-        super(Longitude, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -23496,39 +10762,33 @@ class LongitudeDatum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "longitude"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "LongitudeDatum": ...
+    def bandPosition(self, _: float, **kwds) -> LongitudeDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "LongitudeDatum": ...
+    def title(self, _: str, **kwds) -> LongitudeDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "LongitudeDatum": ...
+    def title(self, _: list[str], **kwds) -> LongitudeDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "LongitudeDatum": ...
+    def title(self, _: None, **kwds) -> LongitudeDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "LongitudeDatum": ...
+    ) -> LongitudeDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(LongitudeDatum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -23655,35 +10915,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Longitude2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Longitude2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Longitude2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Longitude2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Longitude2": ...
+    def bandPosition(self, _: float, **kwds) -> Longitude2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Longitude2": ...
+    def bin(self, _: None, **kwds) -> Longitude2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Longitude2": ...
+    def field(self, _: str, **kwds) -> Longitude2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
@@ -23702,7 +10960,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
@@ -23721,7 +10979,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
@@ -23758,7 +11016,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
@@ -23795,7 +11053,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
@@ -23817,7 +11075,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
@@ -23839,187 +11097,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Longitude2": ...
+    ) -> Longitude2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Longitude2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Longitude2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Longitude2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Longitude2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Longitude2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Longitude2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Longitude2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Longitude2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -24034,8 +11154,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -24050,77 +11170,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(Longitude2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -24240,39 +11295,33 @@ class Longitude2Datum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "longitude2"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Longitude2Datum": ...
+    def bandPosition(self, _: float, **kwds) -> Longitude2Datum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "Longitude2Datum": ...
+    def title(self, _: str, **kwds) -> Longitude2Datum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "Longitude2Datum": ...
+    def title(self, _: list[str], **kwds) -> Longitude2Datum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "Longitude2Datum": ...
+    def title(self, _: None, **kwds) -> Longitude2Datum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "Longitude2Datum": ...
+    ) -> Longitude2Datum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Longitude2Datum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -24296,7 +11345,7 @@ class Longitude2Value(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "longitude2"
 
     def __init__(self, value, **kwds):
-        super(Longitude2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -24558,1971 +11607,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Opacity": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Opacity: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Opacity": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Opacity: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Opacity": ...
+    def bandPosition(self, _: float, **kwds) -> Opacity: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Opacity": ...
+    def bin(self, _: bool, **kwds) -> Opacity: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Opacity": ...
+    def bin(self, _: None, **kwds) -> Opacity: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "Opacity": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> Opacity: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Opacity": ...
+    def field(self, _: str, **kwds) -> Opacity: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Opacity": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Opacity": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Opacity: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Opacity: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Opacity": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Opacity": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Opacity": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Opacity": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Opacity": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Opacity": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Opacity": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Opacity: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Opacity: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Opacity: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Opacity: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Opacity: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Opacity: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Opacity: ...
 
     @overload
     def sort(
@@ -26542,7 +11880,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def sort(
@@ -26562,76 +11900,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Opacity": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Opacity: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Opacity": ...
+    def sort(self, _: None, **kwds) -> Opacity: ...
 
     @overload
     def timeUnit(
@@ -26650,7 +11939,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def timeUnit(
@@ -26669,7 +11958,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def timeUnit(
@@ -26706,7 +11995,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def timeUnit(
@@ -26743,7 +12032,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def timeUnit(
@@ -26765,7 +12054,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def timeUnit(
@@ -26787,236 +12076,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Opacity": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Opacity": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Opacity": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Opacity": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Opacity: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Opacity: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Opacity: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Opacity: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Opacity": ...
+    ) -> Opacity: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -27031,8 +12155,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -27047,82 +12171,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Opacity, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -27254,68 +12309,58 @@ class OpacityDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefn
     _encoding_name = "opacity"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "OpacityDatum": ...
+    def bandPosition(self, _: float, **kwds) -> OpacityDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "OpacityDatum": ...
+    ) -> OpacityDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "OpacityDatum": ...
+    ) -> OpacityDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "OpacityDatum": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> OpacityDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "OpacityDatum": ...
+    def title(self, _: str, **kwds) -> OpacityDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "OpacityDatum": ...
+    def title(self, _: list[str], **kwds) -> OpacityDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "OpacityDatum": ...
+    def title(self, _: None, **kwds) -> OpacityDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "OpacityDatum": ...
+    ) -> OpacityDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(OpacityDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -27348,111 +12393,33 @@ class OpacityValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -27467,8 +12434,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -27483,219 +12450,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "OpacityValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> OpacityValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "OpacityValue": ...
+    ) -> OpacityValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -27710,8 +12517,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -27726,146 +12533,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "OpacityValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> OpacityValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "OpacityValue": ...
+    ) -> OpacityValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "OpacityValue": ...
+    ) -> OpacityValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "OpacityValue": ...
+    ) -> OpacityValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "OpacityValue": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> OpacityValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(OpacityValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -28059,62 +12780,58 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Order": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Order: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Order": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Order: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Order": ...
+    def bandPosition(self, _: float, **kwds) -> Order: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Order": ...
+    def bin(self, _: bool, **kwds) -> Order: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Order": ...
+    def bin(self, _: str, **kwds) -> Order: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Order": ...
+    def bin(self, _: None, **kwds) -> Order: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Order": ...
+    def field(self, _: str, **kwds) -> Order: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Order": ...
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Order: ...
 
     @overload
     def timeUnit(
@@ -28133,7 +12850,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def timeUnit(
@@ -28152,7 +12869,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def timeUnit(
@@ -28189,7 +12906,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def timeUnit(
@@ -28226,7 +12943,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def timeUnit(
@@ -28248,7 +12965,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def timeUnit(
@@ -28270,195 +12987,55 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Order": ...
+    ) -> Order: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Order": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Order": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Order": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Order": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Order: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Order: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Order: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Order: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Order": ...
+    ) -> Order: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        sort: Optional[SchemaBase | SortOrder_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -28473,8 +13050,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -28489,82 +13066,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Order, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -28604,34 +13112,34 @@ class OrderValue(ValueChannelMixin, core.OrderValueDef):
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[float, UndefinedType] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[float] = Undefined,
         **kwds,
-    ) -> "OrderValue": ...
+    ) -> OrderValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[float, UndefinedType] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[float] = Undefined,
         **kwds,
-    ) -> "OrderValue": ...
+    ) -> OrderValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumber], **kwds
-    ) -> "OrderValue": ...
+        self, _: list[core.ConditionalValueDefnumber], **kwds
+    ) -> OrderValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(OrderValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -28906,572 +13414,133 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Radius": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Radius: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Radius": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Radius: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Radius": ...
+    def bandPosition(self, _: float, **kwds) -> Radius: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Radius": ...
+    def bin(self, _: bool, **kwds) -> Radius: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Radius": ...
+    def bin(self, _: str, **kwds) -> Radius: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Radius": ...
+    def bin(self, _: None, **kwds) -> Radius: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Radius": ...
+    def field(self, _: str, **kwds) -> Radius: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Radius": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Radius": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Radius": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Radius": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Radius": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Radius": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Radius": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Radius: ...
 
     @overload
-    def sort(
-        self,
-        _: Literal[
+    def scale(self, _: None, **kwds) -> Radius: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Radius: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Radius: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Radius: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Radius: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Radius: ...
+
+    @overload
+    def sort(
+        self,
+        _: Literal[
             "x",
             "y",
             "color",
@@ -29486,7 +13555,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def sort(
@@ -29506,85 +13575,36 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Radius": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Radius: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Radius": ...
+    def sort(self, _: None, **kwds) -> Radius: ...
 
     @overload
-    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> "Radius": ...
+    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> Radius: ...
 
     @overload
-    def stack(self, _: None, **kwds) -> "Radius": ...
+    def stack(self, _: None, **kwds) -> Radius: ...
 
     @overload
-    def stack(self, _: bool, **kwds) -> "Radius": ...
+    def stack(self, _: bool, **kwds) -> Radius: ...
 
     @overload
     def timeUnit(
@@ -29603,7 +13623,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def timeUnit(
@@ -29622,7 +13642,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def timeUnit(
@@ -29659,7 +13679,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def timeUnit(
@@ -29696,7 +13716,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def timeUnit(
@@ -29718,7 +13738,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def timeUnit(
@@ -29740,239 +13760,68 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Radius": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Radius": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Radius": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Radius": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Radius: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Radius: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Radius: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Radius: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Radius": ...
+    ) -> Radius: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -29987,8 +13836,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30003,82 +13852,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Radius, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -30246,551 +14026,104 @@ class RadiusDatum(DatumChannelMixin, core.PositionDatumDefBase):
     _encoding_name = "radius"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "RadiusDatum": ...
+    def bandPosition(self, _: float, **kwds) -> RadiusDatum: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "RadiusDatum": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "RadiusDatum": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> RadiusDatum: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> RadiusDatum: ...
 
     @overload
     def stack(
         self, _: Literal["zero", "center", "normalize"], **kwds
-    ) -> "RadiusDatum": ...
+    ) -> RadiusDatum: ...
 
     @overload
-    def stack(self, _: None, **kwds) -> "RadiusDatum": ...
+    def stack(self, _: None, **kwds) -> RadiusDatum: ...
 
     @overload
-    def stack(self, _: bool, **kwds) -> "RadiusDatum": ...
+    def stack(self, _: bool, **kwds) -> RadiusDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "RadiusDatum": ...
+    def title(self, _: str, **kwds) -> RadiusDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "RadiusDatum": ...
+    def title(self, _: list[str], **kwds) -> RadiusDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "RadiusDatum": ...
+    def title(self, _: None, **kwds) -> RadiusDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "RadiusDatum": ...
+    ) -> RadiusDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(RadiusDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             scale=scale,
@@ -30820,7 +14153,7 @@ class RadiusValue(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "radius"
 
     def __init__(self, value, **kwds):
-        super(RadiusValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -30945,35 +14278,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Radius2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Radius2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Radius2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Radius2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Radius2": ...
+    def bandPosition(self, _: float, **kwds) -> Radius2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Radius2": ...
+    def bin(self, _: None, **kwds) -> Radius2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Radius2": ...
+    def field(self, _: str, **kwds) -> Radius2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
@@ -30992,7 +14323,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
@@ -31011,7 +14342,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
@@ -31048,7 +14379,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
@@ -31085,7 +14416,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
@@ -31107,7 +14438,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
@@ -31129,187 +14460,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Radius2": ...
+    ) -> Radius2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Radius2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Radius2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Radius2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Radius2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Radius2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Radius2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Radius2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Radius2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -31324,8 +14517,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -31340,77 +14533,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(Radius2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -31530,39 +14658,33 @@ class Radius2Datum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "radius2"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Radius2Datum": ...
+    def bandPosition(self, _: float, **kwds) -> Radius2Datum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "Radius2Datum": ...
+    def title(self, _: str, **kwds) -> Radius2Datum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "Radius2Datum": ...
+    def title(self, _: list[str], **kwds) -> Radius2Datum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "Radius2Datum": ...
+    def title(self, _: None, **kwds) -> Radius2Datum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "Radius2Datum": ...
+    ) -> Radius2Datum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Radius2Datum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -31586,7 +14708,7 @@ class Radius2Value(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "radius2"
 
     def __init__(self, value, **kwds):
-        super(Radius2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -31832,577 +14954,141 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Row": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Row: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Row": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Row: ...
 
     @overload
-    def align(self, _: Literal["all", "each", "none"], **kwds) -> "Row": ...
+    def align(self, _: Literal["all", "each", "none"], **kwds) -> Row: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Row": ...
+    def bandPosition(self, _: float, **kwds) -> Row: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Row": ...
+    def bin(self, _: bool, **kwds) -> Row: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Row": ...
+    def bin(self, _: None, **kwds) -> Row: ...
 
     @overload
-    def center(self, _: bool, **kwds) -> "Row": ...
+    def center(self, _: bool, **kwds) -> Row: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Row": ...
+    def field(self, _: str, **kwds) -> Row: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def header(
         self,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAnchor: Union[
-            core.SchemaBase, Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        labelAngle: Union[float, UndefinedType] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOrient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            core.SchemaBase, Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        titleAngle: Union[float, UndefinedType] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            core.SchemaBase, Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Row": ...
-
-    @overload
-    def header(self, _: None, **kwds) -> "Row": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Row": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Row": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Row": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Row": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Row": ...
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        labelAngle: Optional[float] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        orient: Optional[Orient_T | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        titleAngle: Optional[float] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Row: ...
+
+    @overload
+    def header(self, _: None, **kwds) -> Row: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Row: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Row: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Row: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Row: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Row: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Row": ...
-
-    @overload
-    def sort(self, _: None, **kwds) -> "Row": ...
-
-    @overload
-    def spacing(self, _: float, **kwds) -> "Row": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Row: ...
+
+    @overload
+    def sort(self, _: None, **kwds) -> Row: ...
+
+    @overload
+    def spacing(self, _: float, **kwds) -> Row: ...
 
     @overload
     def timeUnit(
@@ -32421,7 +15107,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def timeUnit(
@@ -32440,7 +15126,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def timeUnit(
@@ -32477,7 +15163,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def timeUnit(
@@ -32514,7 +15200,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def timeUnit(
@@ -32536,7 +15222,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def timeUnit(
@@ -32558,209 +15244,68 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Row": ...
+    ) -> Row: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Row": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Row": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Row": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Row": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Row: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Row: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Row: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Row: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Row": ...
+    ) -> Row: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            core.SchemaBase, Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        header: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        align: Optional[SchemaBase | LayoutAlign_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        center: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        header: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        spacing: Optional[float] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -32775,8 +15320,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -32791,82 +15336,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Row, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             align=align,
@@ -33144,1971 +15620,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Shape": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Shape: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Shape": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Shape: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Shape": ...
+    def bandPosition(self, _: float, **kwds) -> Shape: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Shape": ...
+    def bin(self, _: bool, **kwds) -> Shape: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Shape": ...
+    def bin(self, _: None, **kwds) -> Shape: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "Shape": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> Shape: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Shape": ...
+    def field(self, _: str, **kwds) -> Shape: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Shape": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Shape": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Shape: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Shape: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Shape": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Shape": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Shape": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Shape": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Shape": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Shape": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Shape": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Shape: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Shape: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Shape: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Shape: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Shape: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Shape: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Shape: ...
 
     @overload
     def sort(
@@ -35128,7 +15893,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def sort(
@@ -35148,76 +15913,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Shape": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Shape: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Shape": ...
+    def sort(self, _: None, **kwds) -> Shape: ...
 
     @overload
     def timeUnit(
@@ -35236,7 +15952,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def timeUnit(
@@ -35255,7 +15971,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def timeUnit(
@@ -35292,7 +16008,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def timeUnit(
@@ -35329,7 +16045,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def timeUnit(
@@ -35351,7 +16067,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def timeUnit(
@@ -35373,234 +16089,69 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Shape": ...
+    ) -> Shape: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Shape": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Shape": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Shape": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Shape": ...
-
-    @overload
-    def type(self, _: Literal["nominal", "ordinal", "geojson"], **kwds) -> "Shape": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Shape: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Shape: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Shape: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Shape: ...
+
+    @overload
+    def type(self, _: Literal["nominal", "ordinal", "geojson"], **kwds) -> Shape: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -35615,8 +16166,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -35631,80 +16182,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase, Literal["nominal", "ordinal", "geojson"], UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | TypeForShape_T] = Undefined,
         **kwds,
     ):
-        super(Shape, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -35838,68 +16322,58 @@ class ShapeDatum(
     _encoding_name = "shape"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "ShapeDatum": ...
+    def bandPosition(self, _: float, **kwds) -> ShapeDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ShapeDatum": ...
+    ) -> ShapeDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ShapeDatum": ...
+    ) -> ShapeDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "ShapeDatum": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> ShapeDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "ShapeDatum": ...
+    def title(self, _: str, **kwds) -> ShapeDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "ShapeDatum": ...
+    def title(self, _: list[str], **kwds) -> ShapeDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "ShapeDatum": ...
+    def title(self, _: None, **kwds) -> ShapeDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "ShapeDatum": ...
+    ) -> ShapeDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ShapeDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -35933,111 +16407,33 @@ class ShapeValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -36052,8 +16448,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -36068,217 +16464,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase, Literal["nominal", "ordinal", "geojson"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "ShapeValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | TypeForShape_T] = Undefined,
+        **kwds,
+    ) -> ShapeValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ShapeValue": ...
+    ) -> ShapeValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -36293,8 +16531,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -36309,144 +16547,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase, Literal["nominal", "ordinal", "geojson"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "ShapeValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | TypeForShape_T] = Undefined,
+        **kwds,
+    ) -> ShapeValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ShapeValue": ...
+    ) -> ShapeValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ShapeValue": ...
+    ) -> ShapeValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "ShapeValue": ...
+    ) -> ShapeValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "ShapeValue": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> ShapeValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(ShapeValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -36706,1971 +16860,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Size": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Size: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Size": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Size: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Size": ...
+    def bandPosition(self, _: float, **kwds) -> Size: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Size": ...
+    def bin(self, _: bool, **kwds) -> Size: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Size": ...
+    def bin(self, _: None, **kwds) -> Size: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "Size": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> Size: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Size": ...
+    def field(self, _: str, **kwds) -> Size: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Size": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Size": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Size: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Size: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Size": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Size": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Size": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Size": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Size": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Size": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Size": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Size: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Size: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Size: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Size: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Size: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Size: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Size: ...
 
     @overload
     def sort(
@@ -38690,7 +17133,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def sort(
@@ -38710,76 +17153,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Size": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Size: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Size": ...
+    def sort(self, _: None, **kwds) -> Size: ...
 
     @overload
     def timeUnit(
@@ -38798,7 +17192,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def timeUnit(
@@ -38817,7 +17211,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def timeUnit(
@@ -38854,7 +17248,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def timeUnit(
@@ -38891,7 +17285,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def timeUnit(
@@ -38913,7 +17307,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def timeUnit(
@@ -38935,236 +17329,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Size": ...
+    ) -> Size: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Size": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Size": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Size": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Size": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Size: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Size: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Size: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Size: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Size": ...
+    ) -> Size: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -39179,8 +17408,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -39195,82 +17424,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Size, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -39402,68 +17562,58 @@ class SizeDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionDatumDefnumb
     _encoding_name = "size"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "SizeDatum": ...
+    def bandPosition(self, _: float, **kwds) -> SizeDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "SizeDatum": ...
+    ) -> SizeDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "SizeDatum": ...
+    ) -> SizeDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "SizeDatum": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> SizeDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "SizeDatum": ...
+    def title(self, _: str, **kwds) -> SizeDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "SizeDatum": ...
+    def title(self, _: list[str], **kwds) -> SizeDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "SizeDatum": ...
+    def title(self, _: None, **kwds) -> SizeDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "SizeDatum": ...
+    ) -> SizeDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(SizeDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -39496,111 +17646,33 @@ class SizeValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -39615,8 +17687,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -39631,219 +17703,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "SizeValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> SizeValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "SizeValue": ...
+    ) -> SizeValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -39858,8 +17770,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -39874,146 +17786,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "SizeValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> SizeValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "SizeValue": ...
+    ) -> SizeValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "SizeValue": ...
+    ) -> SizeValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "SizeValue": ...
+    ) -> SizeValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "SizeValue": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> SizeValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(SizeValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -40276,1971 +18102,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Stroke": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Stroke: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Stroke": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Stroke: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Stroke": ...
+    def bandPosition(self, _: float, **kwds) -> Stroke: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Stroke": ...
+    def bin(self, _: bool, **kwds) -> Stroke: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Stroke": ...
+    def bin(self, _: None, **kwds) -> Stroke: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "Stroke": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> Stroke: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Stroke": ...
+    def field(self, _: str, **kwds) -> Stroke: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Stroke": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "Stroke": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Stroke: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> Stroke: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Stroke": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Stroke": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Stroke": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Stroke": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Stroke": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Stroke": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Stroke": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Stroke: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Stroke: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Stroke: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Stroke: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Stroke: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Stroke: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Stroke: ...
 
     @overload
     def sort(
@@ -42260,7 +18375,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def sort(
@@ -42280,76 +18395,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Stroke": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Stroke: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Stroke": ...
+    def sort(self, _: None, **kwds) -> Stroke: ...
 
     @overload
     def timeUnit(
@@ -42368,7 +18434,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def timeUnit(
@@ -42387,7 +18453,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def timeUnit(
@@ -42424,7 +18490,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def timeUnit(
@@ -42461,7 +18527,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def timeUnit(
@@ -42483,7 +18549,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def timeUnit(
@@ -42505,236 +18571,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Stroke": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Stroke": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Stroke": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Stroke": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Stroke: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Stroke: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Stroke: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Stroke: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Stroke": ...
+    ) -> Stroke: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -42749,8 +18650,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -42765,82 +18666,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Stroke, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -42974,68 +18806,58 @@ class StrokeDatum(
     _encoding_name = "stroke"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeDatum": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeDatum": ...
+    ) -> StrokeDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeDatum": ...
+    ) -> StrokeDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "StrokeDatum": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> StrokeDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "StrokeDatum": ...
+    def title(self, _: str, **kwds) -> StrokeDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "StrokeDatum": ...
+    def title(self, _: list[str], **kwds) -> StrokeDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "StrokeDatum": ...
+    def title(self, _: None, **kwds) -> StrokeDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "StrokeDatum": ...
+    ) -> StrokeDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(StrokeDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -43069,111 +18891,33 @@ class StrokeValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -43188,8 +18932,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -43204,219 +18948,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeValue": ...
+    ) -> StrokeValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -43431,8 +19015,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -43447,146 +19031,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeValue": ...
+    ) -> StrokeValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeValue": ...
+    ) -> StrokeValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeValue": ...
+    ) -> StrokeValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefGradientstringnullExprRef], **kwds
-    ) -> "StrokeValue": ...
+        self, _: list[core.ConditionalValueDefGradientstringnullExprRef], **kwds
+    ) -> StrokeValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(StrokeValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -43848,1971 +19346,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "StrokeDash": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> StrokeDash: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "StrokeDash": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> StrokeDash: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeDash": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeDash: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "StrokeDash": ...
+    def bin(self, _: bool, **kwds) -> StrokeDash: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "StrokeDash": ...
+    def bin(self, _: None, **kwds) -> StrokeDash: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberArrayExprRef], **kwds
-    ) -> "StrokeDash": ...
+        self, _: list[core.ConditionalValueDefnumberArrayExprRef], **kwds
+    ) -> StrokeDash: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "StrokeDash": ...
+    def field(self, _: str, **kwds) -> StrokeDash: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "StrokeDash": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "StrokeDash": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> StrokeDash: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> StrokeDash: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeDash": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "StrokeDash": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "StrokeDash": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "StrokeDash": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "StrokeDash": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "StrokeDash": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "StrokeDash": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> StrokeDash: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> StrokeDash: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> StrokeDash: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> StrokeDash: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> StrokeDash: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> StrokeDash: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> StrokeDash: ...
 
     @overload
     def sort(
@@ -45832,7 +19619,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def sort(
@@ -45852,76 +19639,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeDash": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> StrokeDash: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "StrokeDash": ...
+    def sort(self, _: None, **kwds) -> StrokeDash: ...
 
     @overload
     def timeUnit(
@@ -45940,7 +19678,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def timeUnit(
@@ -45959,7 +19697,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def timeUnit(
@@ -45996,7 +19734,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def timeUnit(
@@ -46033,7 +19771,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def timeUnit(
@@ -46055,7 +19793,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def timeUnit(
@@ -46077,236 +19815,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "StrokeDash": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "StrokeDash": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "StrokeDash": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "StrokeDash": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> StrokeDash: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> StrokeDash: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> StrokeDash: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> StrokeDash: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "StrokeDash": ...
+    ) -> StrokeDash: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -46321,8 +19894,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -46337,82 +19910,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(StrokeDash, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -46546,68 +20050,58 @@ class StrokeDashDatum(
     _encoding_name = "strokeDash"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeDashDatum": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeDashDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDashDatum": ...
+    ) -> StrokeDashDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDashDatum": ...
+    ) -> StrokeDashDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberArrayExprRef], **kwds
-    ) -> "StrokeDashDatum": ...
+        self, _: list[core.ConditionalValueDefnumberArrayExprRef], **kwds
+    ) -> StrokeDashDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "StrokeDashDatum": ...
+    def title(self, _: str, **kwds) -> StrokeDashDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "StrokeDashDatum": ...
+    def title(self, _: list[str], **kwds) -> StrokeDashDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "StrokeDashDatum": ...
+    def title(self, _: None, **kwds) -> StrokeDashDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "StrokeDashDatum": ...
+    ) -> StrokeDashDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(StrokeDashDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -46640,111 +20134,33 @@ class StrokeDashValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -46759,8 +20175,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -46775,219 +20191,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeDashValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeDashValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeDashValue": ...
+    ) -> StrokeDashValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -47002,8 +20258,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -47018,146 +20274,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeDashValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeDashValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeDashValue": ...
+    ) -> StrokeDashValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDashValue": ...
+    ) -> StrokeDashValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeDashValue": ...
+    ) -> StrokeDashValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberArrayExprRef], **kwds
-    ) -> "StrokeDashValue": ...
+        self, _: list[core.ConditionalValueDefnumberArrayExprRef], **kwds
+    ) -> StrokeDashValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(StrokeDashValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -47419,1973 +20589,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "StrokeOpacity": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> StrokeOpacity: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "StrokeOpacity": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> StrokeOpacity: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeOpacity": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeOpacity: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "StrokeOpacity": ...
+    def bin(self, _: bool, **kwds) -> StrokeOpacity: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "StrokeOpacity": ...
+    def bin(self, _: None, **kwds) -> StrokeOpacity: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> StrokeOpacity: ...
+
+    @overload
+    def condition(
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> StrokeOpacity: ...
+
+    @overload
+    def field(self, _: str, **kwds) -> StrokeOpacity: ...
+
+    @overload
+    def field(
+        self,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
+        **kwds,
+    ) -> StrokeOpacity: ...
+
+    @overload
+    def legend(
+        self,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> StrokeOpacity: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> StrokeOpacity: ...
+
+    @overload
+    def scale(
+        self,
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
         ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
-    def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "StrokeOpacity": ...
+    def scale(self, _: None, **kwds) -> StrokeOpacity: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "StrokeOpacity": ...
+    def sort(self, _: list[float], **kwds) -> StrokeOpacity: ...
 
     @overload
-    def field(
-        self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacity": ...
+    def sort(self, _: list[str], **kwds) -> StrokeOpacity: ...
 
     @overload
-    def legend(
-        self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacity": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "StrokeOpacity": ...
+    def sort(self, _: list[bool], **kwds) -> StrokeOpacity: ...
 
     @overload
-    def scale(
-        self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacity": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "StrokeOpacity": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "StrokeOpacity": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "StrokeOpacity": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "StrokeOpacity": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "StrokeOpacity": ...
+    def sort(self, _: list[core.DateTime], **kwds) -> StrokeOpacity: ...
 
     @overload
-    def sort(
-        self, _: Literal["ascending", "descending"], **kwds
-    ) -> "StrokeOpacity": ...
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> StrokeOpacity: ...
 
     @overload
     def sort(
@@ -49405,7 +20862,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def sort(
@@ -49425,76 +20882,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacity": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> StrokeOpacity: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "StrokeOpacity": ...
+    def sort(self, _: None, **kwds) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
@@ -49513,7 +20921,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
@@ -49532,7 +20940,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
@@ -49569,7 +20977,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
@@ -49606,7 +21014,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
@@ -49628,7 +21036,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
@@ -49650,236 +21058,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacity": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "StrokeOpacity": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "StrokeOpacity": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "StrokeOpacity": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> StrokeOpacity: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> StrokeOpacity: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> StrokeOpacity: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> StrokeOpacity: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "StrokeOpacity": ...
+    ) -> StrokeOpacity: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -49894,8 +21137,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -49910,82 +21153,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(StrokeOpacity, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -50119,68 +21293,58 @@ class StrokeOpacityDatum(
     _encoding_name = "strokeOpacity"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeOpacityDatum": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeOpacityDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacityDatum": ...
+    ) -> StrokeOpacityDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacityDatum": ...
+    ) -> StrokeOpacityDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "StrokeOpacityDatum": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> StrokeOpacityDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "StrokeOpacityDatum": ...
+    def title(self, _: str, **kwds) -> StrokeOpacityDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "StrokeOpacityDatum": ...
+    def title(self, _: list[str], **kwds) -> StrokeOpacityDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "StrokeOpacityDatum": ...
+    def title(self, _: None, **kwds) -> StrokeOpacityDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "StrokeOpacityDatum": ...
+    ) -> StrokeOpacityDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(StrokeOpacityDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -50213,111 +21377,33 @@ class StrokeOpacityValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -50332,8 +21418,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -50348,219 +21434,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacityValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeOpacityValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacityValue": ...
+    ) -> StrokeOpacityValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -50575,8 +21501,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -50591,148 +21517,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeOpacityValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeOpacityValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacityValue": ...
+    ) -> StrokeOpacityValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacityValue": ...
+    ) -> StrokeOpacityValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeOpacityValue": ...
+    ) -> StrokeOpacityValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "StrokeOpacityValue": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> StrokeOpacityValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(StrokeOpacityValue, self).__init__(
-            value=value, condition=condition, **kwds
-        )
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -50994,1971 +21832,260 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "StrokeWidth": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> StrokeWidth: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "StrokeWidth": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> StrokeWidth: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeWidth": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeWidth: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "StrokeWidth": ...
+    def bin(self, _: bool, **kwds) -> StrokeWidth: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "StrokeWidth": ...
+    def bin(self, _: None, **kwds) -> StrokeWidth: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "StrokeWidth": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> StrokeWidth: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "StrokeWidth": ...
+    def field(self, _: str, **kwds) -> StrokeWidth: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def legend(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        clipHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        direction: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            core.SchemaBase,
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "StrokeWidth": ...
-
-    @overload
-    def legend(self, _: None, **kwds) -> "StrokeWidth": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> StrokeWidth: ...
+
+    @overload
+    def legend(self, _: None, **kwds) -> StrokeWidth: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeWidth": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "StrokeWidth": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> StrokeWidth: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> StrokeWidth: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> StrokeWidth: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> StrokeWidth: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> StrokeWidth: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> StrokeWidth: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> StrokeWidth: ...
 
     @overload
     def sort(
@@ -52978,7 +22105,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def sort(
@@ -52998,76 +22125,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeWidth": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> StrokeWidth: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "StrokeWidth": ...
+    def sort(self, _: None, **kwds) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
@@ -53086,7 +22164,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
@@ -53105,7 +22183,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
@@ -53142,7 +22220,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
@@ -53179,7 +22257,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
@@ -53201,7 +22279,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
@@ -53223,236 +22301,71 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "StrokeWidth": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "StrokeWidth": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "StrokeWidth": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> StrokeWidth: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> StrokeWidth: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> StrokeWidth: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> StrokeWidth: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "StrokeWidth": ...
+    ) -> StrokeWidth: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -53467,8 +22380,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -53483,82 +22396,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(StrokeWidth, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -53692,68 +22536,58 @@ class StrokeWidthDatum(
     _encoding_name = "strokeWidth"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "StrokeWidthDatum": ...
+    def bandPosition(self, _: float, **kwds) -> StrokeWidthDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidthDatum": ...
+    ) -> StrokeWidthDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidthDatum": ...
+    ) -> StrokeWidthDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "StrokeWidthDatum": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> StrokeWidthDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "StrokeWidthDatum": ...
+    def title(self, _: str, **kwds) -> StrokeWidthDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "StrokeWidthDatum": ...
+    def title(self, _: list[str], **kwds) -> StrokeWidthDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "StrokeWidthDatum": ...
+    def title(self, _: None, **kwds) -> StrokeWidthDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "StrokeWidthDatum": ...
+    ) -> StrokeWidthDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(StrokeWidthDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -53786,111 +22620,33 @@ class StrokeWidthValue(
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -53905,8 +22661,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -53921,219 +22677,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeWidthValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeWidthValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidthValue": ...
+    ) -> StrokeWidthValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -54148,8 +22744,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -54164,146 +22760,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "StrokeWidthValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> StrokeWidthValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidthValue": ...
+    ) -> StrokeWidthValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidthValue": ...
+    ) -> StrokeWidthValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "StrokeWidthValue": ...
+    ) -> StrokeWidthValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefnumberExprRef], **kwds
-    ) -> "StrokeWidthValue": ...
+        self, _: list[core.ConditionalValueDefnumberExprRef], **kwds
+    ) -> StrokeWidthValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(StrokeWidthValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -54536,94 +23046,90 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Text": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Text: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Text": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Text: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Text": ...
+    def bandPosition(self, _: float, **kwds) -> Text: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Text": ...
+    def bin(self, _: bool, **kwds) -> Text: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Text": ...
+    def bin(self, _: str, **kwds) -> Text: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Text": ...
+    def bin(self, _: None, **kwds) -> Text: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefTextExprRef], **kwds
-    ) -> "Text": ...
+        self, _: list[core.ConditionalValueDefTextExprRef], **kwds
+    ) -> Text: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Text": ...
+    def field(self, _: str, **kwds) -> Text: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
-    def format(self, _: str, **kwds) -> "Text": ...
+    def format(self, _: str, **kwds) -> Text: ...
 
     @overload
-    def format(self, _: dict, **kwds) -> "Text": ...
+    def format(self, _: dict, **kwds) -> Text: ...
 
     @overload
-    def formatType(self, _: str, **kwds) -> "Text": ...
+    def formatType(self, _: str, **kwds) -> Text: ...
 
     @overload
     def timeUnit(
@@ -54642,7 +23148,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def timeUnit(
@@ -54661,7 +23167,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def timeUnit(
@@ -54698,7 +23204,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def timeUnit(
@@ -54735,7 +23241,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def timeUnit(
@@ -54757,7 +23263,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def timeUnit(
@@ -54779,197 +23285,59 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Text": ...
+    ) -> Text: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Text": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Text": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Text": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Text": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Text: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Text: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Text: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Text: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Text": ...
+    ) -> Text: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -54984,8 +23352,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -55000,82 +23368,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Text, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -55240,79 +23539,73 @@ class TextDatum(DatumChannelMixin, core.FieldOrDatumDefWithConditionStringDatumD
     _encoding_name = "text"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "TextDatum": ...
+    def bandPosition(self, _: float, **kwds) -> TextDatum: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
-    ) -> "TextDatum": ...
+    ) -> TextDatum: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
-    ) -> "TextDatum": ...
+    ) -> TextDatum: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefTextExprRef], **kwds
-    ) -> "TextDatum": ...
+        self, _: list[core.ConditionalValueDefTextExprRef], **kwds
+    ) -> TextDatum: ...
 
     @overload
-    def format(self, _: str, **kwds) -> "TextDatum": ...
+    def format(self, _: str, **kwds) -> TextDatum: ...
 
     @overload
-    def format(self, _: dict, **kwds) -> "TextDatum": ...
+    def format(self, _: dict, **kwds) -> TextDatum: ...
 
     @overload
-    def formatType(self, _: str, **kwds) -> "TextDatum": ...
+    def formatType(self, _: str, **kwds) -> TextDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "TextDatum": ...
+    def title(self, _: str, **kwds) -> TextDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "TextDatum": ...
+    def title(self, _: list[str], **kwds) -> TextDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "TextDatum": ...
+    def title(self, _: None, **kwds) -> TextDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "TextDatum": ...
+    ) -> TextDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TextDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             condition=condition,
@@ -55345,72 +23638,21 @@ class TextValue(ValueChannelMixin, core.ValueDefWithConditionStringFieldDefText)
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -55425,8 +23667,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -55441,152 +23683,32 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "TextValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> TextValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -55601,8 +23723,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -55617,117 +23739,48 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "TextValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> TextValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
-    ) -> "TextValue": ...
+    ) -> TextValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
-    ) -> "TextValue": ...
+    ) -> TextValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefTextExprRef], **kwds
-    ) -> "TextValue": ...
+        self, _: list[core.ConditionalValueDefTextExprRef], **kwds
+    ) -> TextValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(TextValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -56002,567 +24055,128 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Theta": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Theta: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Theta": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Theta: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Theta": ...
+    def bandPosition(self, _: float, **kwds) -> Theta: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Theta": ...
+    def bin(self, _: bool, **kwds) -> Theta: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Theta": ...
+    def bin(self, _: str, **kwds) -> Theta: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Theta": ...
+    def bin(self, _: None, **kwds) -> Theta: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Theta": ...
+    def field(self, _: str, **kwds) -> Theta: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Theta": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Theta": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Theta": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Theta": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Theta": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Theta": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Theta": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Theta: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Theta: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Theta: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Theta: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Theta: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Theta: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Theta: ...
 
     @overload
     def sort(
@@ -56582,7 +24196,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def sort(
@@ -56602,85 +24216,36 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Theta": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Theta: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Theta": ...
+    def sort(self, _: None, **kwds) -> Theta: ...
 
     @overload
-    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> "Theta": ...
+    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> Theta: ...
 
     @overload
-    def stack(self, _: None, **kwds) -> "Theta": ...
+    def stack(self, _: None, **kwds) -> Theta: ...
 
     @overload
-    def stack(self, _: bool, **kwds) -> "Theta": ...
+    def stack(self, _: bool, **kwds) -> Theta: ...
 
     @overload
     def timeUnit(
@@ -56699,7 +24264,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def timeUnit(
@@ -56718,7 +24283,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def timeUnit(
@@ -56755,7 +24320,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def timeUnit(
@@ -56792,7 +24357,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def timeUnit(
@@ -56814,7 +24379,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def timeUnit(
@@ -56836,239 +24401,68 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Theta": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Theta": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Theta": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Theta": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Theta: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Theta: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Theta: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Theta: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Theta": ...
+    ) -> Theta: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -57083,8 +24477,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -57099,82 +24493,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Theta, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -57342,551 +24667,104 @@ class ThetaDatum(DatumChannelMixin, core.PositionDatumDefBase):
     _encoding_name = "theta"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "ThetaDatum": ...
+    def bandPosition(self, _: float, **kwds) -> ThetaDatum: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "ThetaDatum": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "ThetaDatum": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> ThetaDatum: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> ThetaDatum: ...
 
     @overload
     def stack(
         self, _: Literal["zero", "center", "normalize"], **kwds
-    ) -> "ThetaDatum": ...
+    ) -> ThetaDatum: ...
 
     @overload
-    def stack(self, _: None, **kwds) -> "ThetaDatum": ...
+    def stack(self, _: None, **kwds) -> ThetaDatum: ...
 
     @overload
-    def stack(self, _: bool, **kwds) -> "ThetaDatum": ...
+    def stack(self, _: bool, **kwds) -> ThetaDatum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "ThetaDatum": ...
+    def title(self, _: str, **kwds) -> ThetaDatum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "ThetaDatum": ...
+    def title(self, _: list[str], **kwds) -> ThetaDatum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "ThetaDatum": ...
+    def title(self, _: None, **kwds) -> ThetaDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "ThetaDatum": ...
+    ) -> ThetaDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ThetaDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             scale=scale,
@@ -57916,7 +24794,7 @@ class ThetaValue(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "theta"
 
     def __init__(self, value, **kwds):
-        super(ThetaValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -58041,35 +24919,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Theta2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Theta2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Theta2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Theta2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Theta2": ...
+    def bandPosition(self, _: float, **kwds) -> Theta2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Theta2": ...
+    def bin(self, _: None, **kwds) -> Theta2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Theta2": ...
+    def field(self, _: str, **kwds) -> Theta2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
@@ -58088,7 +24964,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
@@ -58107,7 +24983,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
@@ -58144,7 +25020,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
@@ -58181,7 +25057,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
@@ -58203,7 +25079,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
@@ -58225,187 +25101,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Theta2": ...
+    ) -> Theta2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Theta2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Theta2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Theta2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Theta2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Theta2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Theta2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Theta2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Theta2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -58420,8 +25158,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -58436,77 +25174,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(Theta2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -58626,39 +25299,33 @@ class Theta2Datum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "theta2"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Theta2Datum": ...
+    def bandPosition(self, _: float, **kwds) -> Theta2Datum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "Theta2Datum": ...
+    def title(self, _: str, **kwds) -> Theta2Datum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "Theta2Datum": ...
+    def title(self, _: list[str], **kwds) -> Theta2Datum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "Theta2Datum": ...
+    def title(self, _: None, **kwds) -> Theta2Datum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "Theta2Datum": ...
+    ) -> Theta2Datum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Theta2Datum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -58682,7 +25349,7 @@ class Theta2Value(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "theta2"
 
     def __init__(self, value, **kwds):
-        super(Theta2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -58915,94 +25582,86 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Tooltip": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Tooltip: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Tooltip": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Tooltip: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Tooltip": ...
+    def bandPosition(self, _: float, **kwds) -> Tooltip: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Tooltip": ...
+    def bin(self, _: bool, **kwds) -> Tooltip: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Tooltip": ...
+    def bin(self, _: str, **kwds) -> Tooltip: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Tooltip": ...
+    def bin(self, _: None, **kwds) -> Tooltip: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringExprRef], **kwds
-    ) -> "Tooltip": ...
+        self, _: list[core.ConditionalValueDefstringExprRef], **kwds
+    ) -> Tooltip: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Tooltip": ...
+    def field(self, _: str, **kwds) -> Tooltip: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
-    def format(self, _: str, **kwds) -> "Tooltip": ...
+    def format(self, _: str, **kwds) -> Tooltip: ...
 
     @overload
-    def format(self, _: dict, **kwds) -> "Tooltip": ...
+    def format(self, _: dict, **kwds) -> Tooltip: ...
 
     @overload
-    def formatType(self, _: str, **kwds) -> "Tooltip": ...
+    def formatType(self, _: str, **kwds) -> Tooltip: ...
 
     @overload
     def timeUnit(
@@ -59021,7 +25680,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def timeUnit(
@@ -59040,7 +25699,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def timeUnit(
@@ -59077,7 +25736,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def timeUnit(
@@ -59114,7 +25773,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def timeUnit(
@@ -59136,7 +25795,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def timeUnit(
@@ -59158,197 +25817,59 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Tooltip": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Tooltip": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Tooltip": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Tooltip": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Tooltip: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Tooltip: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Tooltip: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Tooltip: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Tooltip": ...
+    ) -> Tooltip: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -59363,8 +25884,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -59379,82 +25900,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Tooltip, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -59491,111 +25943,33 @@ class TooltipValue(ValueChannelMixin, core.StringValueDefWithCondition):
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -59610,8 +25984,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -59626,219 +26000,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "TooltipValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> TooltipValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "TooltipValue": ...
+    ) -> TooltipValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -59853,8 +26067,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -59869,146 +26083,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "TooltipValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> TooltipValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "TooltipValue": ...
+    ) -> TooltipValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "TooltipValue": ...
+    ) -> TooltipValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "TooltipValue": ...
+    ) -> TooltipValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "TooltipValue": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> TooltipValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(TooltipValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -60241,94 +26369,86 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Url": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Url: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Url": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Url: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Url": ...
+    def bandPosition(self, _: float, **kwds) -> Url: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "Url": ...
+    def bin(self, _: bool, **kwds) -> Url: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Url": ...
+    def bin(self, _: str, **kwds) -> Url: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Url": ...
+    def bin(self, _: None, **kwds) -> Url: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringExprRef], **kwds
-    ) -> "Url": ...
+        self, _: list[core.ConditionalValueDefstringExprRef], **kwds
+    ) -> Url: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Url": ...
+    def field(self, _: str, **kwds) -> Url: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
-    def format(self, _: str, **kwds) -> "Url": ...
+    def format(self, _: str, **kwds) -> Url: ...
 
     @overload
-    def format(self, _: dict, **kwds) -> "Url": ...
+    def format(self, _: dict, **kwds) -> Url: ...
 
     @overload
-    def formatType(self, _: str, **kwds) -> "Url": ...
+    def formatType(self, _: str, **kwds) -> Url: ...
 
     @overload
     def timeUnit(
@@ -60347,7 +26467,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def timeUnit(
@@ -60366,7 +26486,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def timeUnit(
@@ -60403,7 +26523,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def timeUnit(
@@ -60440,7 +26560,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def timeUnit(
@@ -60462,7 +26582,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def timeUnit(
@@ -60484,197 +26604,59 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Url": ...
+    ) -> Url: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Url": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Url": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Url": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Url": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Url: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Url: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Url: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Url: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Url": ...
+    ) -> Url: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -60689,8 +26671,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -60705,82 +26687,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Url, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -60817,111 +26730,33 @@ class UrlValue(ValueChannelMixin, core.StringValueDefWithCondition):
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -60936,8 +26771,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -60952,219 +26787,59 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "UrlValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> UrlValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "UrlValue": ...
+    ) -> UrlValue: ...
 
     @overload
     def condition(
         self,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -61179,8 +26854,8 @@ def condition(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -61195,146 +26870,60 @@ def condition(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
-        ] = Undefined,
-        **kwds,
-    ) -> "UrlValue": ...
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
+        **kwds,
+    ) -> UrlValue: ...
 
     @overload
     def condition(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        legend: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
-    ) -> "UrlValue": ...
+    ) -> UrlValue: ...
 
     @overload
     def condition(
         self,
-        test: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "UrlValue": ...
+    ) -> UrlValue: ...
 
     @overload
     def condition(
         self,
-        empty: Union[bool, UndefinedType] = Undefined,
-        param: Union[str, core.SchemaBase, UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        empty: Optional[bool] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
-    ) -> "UrlValue": ...
+    ) -> UrlValue: ...
 
     @overload
     def condition(
-        self, _: List[core.ConditionalValueDefstringnullExprRef], **kwds
-    ) -> "UrlValue": ...
+        self, _: list[core.ConditionalValueDefstringnullExprRef], **kwds
+    ) -> UrlValue: ...
 
     def __init__(
         self,
         value,
-        condition: Union[
-            dict, core.SchemaBase, Sequence[Union[dict, core.SchemaBase]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(UrlValue, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 @with_property_setters
@@ -61626,1677 +27215,262 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "X": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> X: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "X": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> X: ...
 
     @overload
     def axis(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandPosition: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[bool, UndefinedType] = Undefined,
-        domainCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        domainColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        domainDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        grid: Union[bool, UndefinedType] = Undefined,
-        gridCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        gridColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gridDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        gridDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelBound: Union[
-            bool, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFlush: Union[bool, float, UndefinedType] = Undefined,
-        labelFlushOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        maxExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "bottom", "left", "right"],
-            UndefinedType,
-        ] = Undefined,
-        position: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tickBand: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["center", "extent"],
-            UndefinedType,
-        ] = Undefined,
-        tickCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        tickColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        tickDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickExtra: Union[bool, UndefinedType] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickRound: Union[bool, UndefinedType] = Undefined,
-        tickSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ticks: Union[bool, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        translate: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "X": ...
-
-    @overload
-    def axis(self, _: None, **kwds) -> "X": ...
-
-    @overload
-    def bandPosition(self, _: float, **kwds) -> "X": ...
-
-    @overload
-    def bin(self, _: bool, **kwds) -> "X": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandPosition: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        domain: Optional[bool] = Undefined,
+        domainCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        domainColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        domainDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        domainDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        grid: Optional[bool] = Undefined,
+        gridCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        gridColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gridDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        gridDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelBound: Optional[bool | dict | float | Parameter | SchemaBase] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFlush: Optional[bool | float] = Undefined,
+        labelFlushOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        maxExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | AxisOrient_T] = Undefined,
+        position: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tickBand: Optional[
+            dict | Parameter | SchemaBase | Literal["center", "extent"]
+        ] = Undefined,
+        tickCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        tickColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        tickDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickExtra: Optional[bool] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickRound: Optional[bool] = Undefined,
+        tickSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ticks: Optional[bool] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> X: ...
+
+    @overload
+    def axis(self, _: None, **kwds) -> X: ...
+
+    @overload
+    def bandPosition(self, _: float, **kwds) -> X: ...
+
+    @overload
+    def bin(self, _: bool, **kwds) -> X: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "X": ...
+    def bin(self, _: str, **kwds) -> X: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "X": ...
+    def bin(self, _: None, **kwds) -> X: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "X": ...
+    def field(self, _: str, **kwds) -> X: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def impute(
         self,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        keyvals: Union[dict, Sequence[Any], core.SchemaBase, UndefinedType] = Undefined,
-        method: Union[
-            core.SchemaBase,
-            Literal["value", "median", "max", "min", "mean"],
-            UndefinedType,
-        ] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        keyvals: Optional[dict | SchemaBase | Sequence[Any]] = Undefined,
+        method: Optional[SchemaBase | ImputeMethod_T] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
-    def impute(self, _: None, **kwds) -> "X": ...
+    def impute(self, _: None, **kwds) -> X: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "X": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "X": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "X": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "X": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "X": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "X": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "X": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> X: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> X: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> X: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> X: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> X: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> X: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> X: ...
 
     @overload
     def sort(
@@ -63316,7 +27490,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def sort(
@@ -63336,85 +27510,36 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "X": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> X: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "X": ...
+    def sort(self, _: None, **kwds) -> X: ...
 
     @overload
-    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> "X": ...
+    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> X: ...
 
     @overload
-    def stack(self, _: None, **kwds) -> "X": ...
+    def stack(self, _: None, **kwds) -> X: ...
 
     @overload
-    def stack(self, _: bool, **kwds) -> "X": ...
+    def stack(self, _: bool, **kwds) -> X: ...
 
     @overload
     def timeUnit(
@@ -63433,7 +27558,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def timeUnit(
@@ -63452,7 +27577,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def timeUnit(
@@ -63489,7 +27614,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def timeUnit(
@@ -63526,7 +27651,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def timeUnit(
@@ -63548,7 +27673,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def timeUnit(
@@ -63570,241 +27695,70 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "X": ...
+    ) -> X: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "X": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "X": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "X": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "X": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> X: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> X: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> X: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> X: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "X": ...
+    ) -> X: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        axis: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        impute: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        axis: Optional[dict | None | SchemaBase] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        impute: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -63819,8 +27773,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -63835,82 +27789,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(X, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             axis=axis,
@@ -64099,1659 +27984,236 @@ class XDatum(DatumChannelMixin, core.PositionDatumDef):
     @overload
     def axis(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandPosition: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[bool, UndefinedType] = Undefined,
-        domainCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        domainColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        domainDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        grid: Union[bool, UndefinedType] = Undefined,
-        gridCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        gridColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gridDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        gridDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelBound: Union[
-            bool, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFlush: Union[bool, float, UndefinedType] = Undefined,
-        labelFlushOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        maxExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "bottom", "left", "right"],
-            UndefinedType,
-        ] = Undefined,
-        position: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tickBand: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["center", "extent"],
-            UndefinedType,
-        ] = Undefined,
-        tickCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        tickColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        tickDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickExtra: Union[bool, UndefinedType] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickRound: Union[bool, UndefinedType] = Undefined,
-        tickSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ticks: Union[bool, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        translate: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "XDatum": ...
-
-    @overload
-    def axis(self, _: None, **kwds) -> "XDatum": ...
-
-    @overload
-    def bandPosition(self, _: float, **kwds) -> "XDatum": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandPosition: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        domain: Optional[bool] = Undefined,
+        domainCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        domainColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        domainDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        domainDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        grid: Optional[bool] = Undefined,
+        gridCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        gridColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gridDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        gridDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelBound: Optional[bool | dict | float | Parameter | SchemaBase] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFlush: Optional[bool | float] = Undefined,
+        labelFlushOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        maxExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | AxisOrient_T] = Undefined,
+        position: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tickBand: Optional[
+            dict | Parameter | SchemaBase | Literal["center", "extent"]
+        ] = Undefined,
+        tickCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        tickColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        tickDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickExtra: Optional[bool] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickRound: Optional[bool] = Undefined,
+        tickSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ticks: Optional[bool] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> XDatum: ...
+
+    @overload
+    def axis(self, _: None, **kwds) -> XDatum: ...
+
+    @overload
+    def bandPosition(self, _: float, **kwds) -> XDatum: ...
 
     @overload
     def impute(
         self,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        keyvals: Union[dict, Sequence[Any], core.SchemaBase, UndefinedType] = Undefined,
-        method: Union[
-            core.SchemaBase,
-            Literal["value", "median", "max", "min", "mean"],
-            UndefinedType,
-        ] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        keyvals: Optional[dict | SchemaBase | Sequence[Any]] = Undefined,
+        method: Optional[SchemaBase | ImputeMethod_T] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
-    ) -> "XDatum": ...
+    ) -> XDatum: ...
 
     @overload
-    def impute(self, _: None, **kwds) -> "XDatum": ...
+    def impute(self, _: None, **kwds) -> XDatum: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "XDatum": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "XDatum": ...
-
-    @overload
-    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> "XDatum": ...
-
-    @overload
-    def stack(self, _: None, **kwds) -> "XDatum": ...
-
-    @overload
-    def stack(self, _: bool, **kwds) -> "XDatum": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "XDatum": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "XDatum": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "XDatum": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> XDatum: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> XDatum: ...
+
+    @overload
+    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> XDatum: ...
+
+    @overload
+    def stack(self, _: None, **kwds) -> XDatum: ...
+
+    @overload
+    def stack(self, _: bool, **kwds) -> XDatum: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> XDatum: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> XDatum: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> XDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "XDatum": ...
+    ) -> XDatum: ...
 
     def __init__(
         self,
         datum,
-        axis: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        impute: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        axis: Optional[dict | None | SchemaBase] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        impute: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(XDatum, self).__init__(
+        super().__init__(
             datum=datum,
             axis=axis,
             bandPosition=bandPosition,
@@ -65783,7 +28245,7 @@ class XValue(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "x"
 
     def __init__(self, value, **kwds):
-        super(XValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -65908,35 +28370,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "X2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> X2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "X2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> X2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "X2": ...
+    def bandPosition(self, _: float, **kwds) -> X2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "X2": ...
+    def bin(self, _: None, **kwds) -> X2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "X2": ...
+    def field(self, _: str, **kwds) -> X2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
@@ -65955,7 +28415,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
@@ -65974,7 +28434,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
@@ -66011,7 +28471,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
@@ -66048,7 +28508,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
@@ -66070,7 +28530,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
@@ -66092,187 +28552,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "X2": ...
+    ) -> X2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "X2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "X2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "X2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "X2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> X2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> X2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> X2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> X2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -66287,8 +28609,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -66303,77 +28625,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(X2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -66493,39 +28750,33 @@ class X2Datum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "x2"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "X2Datum": ...
+    def bandPosition(self, _: float, **kwds) -> X2Datum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "X2Datum": ...
+    def title(self, _: str, **kwds) -> X2Datum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "X2Datum": ...
+    def title(self, _: list[str], **kwds) -> X2Datum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "X2Datum": ...
+    def title(self, _: None, **kwds) -> X2Datum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "X2Datum": ...
+    ) -> X2Datum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(X2Datum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -66549,7 +28800,7 @@ class X2Value(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "x2"
 
     def __init__(self, value, **kwds):
-        super(X2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -66674,35 +28925,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "XError": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> XError: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "XError": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> XError: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "XError": ...
+    def bandPosition(self, _: float, **kwds) -> XError: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "XError": ...
+    def bin(self, _: None, **kwds) -> XError: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "XError": ...
+    def field(self, _: str, **kwds) -> XError: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
@@ -66721,7 +28970,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
@@ -66740,7 +28989,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
@@ -66777,7 +29026,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
@@ -66814,7 +29063,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
@@ -66836,7 +29085,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
@@ -66858,187 +29107,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "XError": ...
+    ) -> XError: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "XError": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "XError": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "XError": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "XError": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> XError: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> XError: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> XError: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> XError: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -67053,8 +29164,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -67069,77 +29180,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(XError, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -67170,7 +29216,7 @@ class XErrorValue(ValueChannelMixin, core.ValueDefnumber):
     _encoding_name = "xError"
 
     def __init__(self, value, **kwds):
-        super(XErrorValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -67295,35 +29341,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "XError2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> XError2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "XError2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> XError2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "XError2": ...
+    def bandPosition(self, _: float, **kwds) -> XError2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "XError2": ...
+    def bin(self, _: None, **kwds) -> XError2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "XError2": ...
+    def field(self, _: str, **kwds) -> XError2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
@@ -67342,7 +29386,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
@@ -67361,7 +29405,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
@@ -67398,7 +29442,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
@@ -67435,7 +29479,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
@@ -67457,7 +29501,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
@@ -67479,187 +29523,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "XError2": ...
+    ) -> XError2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "XError2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "XError2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "XError2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "XError2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> XError2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> XError2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> XError2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> XError2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -67674,8 +29580,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -67690,77 +29596,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(XError2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -67791,7 +29632,7 @@ class XError2Value(ValueChannelMixin, core.ValueDefnumber):
     _encoding_name = "xError2"
 
     def __init__(self, value, **kwds):
-        super(XError2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -68035,564 +29876,125 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "XOffset": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> XOffset: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "XOffset": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> XOffset: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "XOffset": ...
+    def bandPosition(self, _: float, **kwds) -> XOffset: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "XOffset": ...
+    def bin(self, _: bool, **kwds) -> XOffset: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "XOffset": ...
+    def bin(self, _: None, **kwds) -> XOffset: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "XOffset": ...
+    def field(self, _: str, **kwds) -> XOffset: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "XOffset": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "XOffset": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "XOffset": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "XOffset": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "XOffset": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "XOffset": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "XOffset": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> XOffset: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> XOffset: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> XOffset: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> XOffset: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> XOffset: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> XOffset: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> XOffset: ...
 
     @overload
     def sort(
@@ -68612,7 +30014,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def sort(
@@ -68632,76 +30034,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "XOffset": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> XOffset: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "XOffset": ...
+    def sort(self, _: None, **kwds) -> XOffset: ...
 
     @overload
     def timeUnit(
@@ -68720,7 +30073,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def timeUnit(
@@ -68739,7 +30092,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def timeUnit(
@@ -68776,7 +30129,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def timeUnit(
@@ -68813,7 +30166,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def timeUnit(
@@ -68835,7 +30188,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def timeUnit(
@@ -68857,232 +30210,67 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "XOffset": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "XOffset": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "XOffset": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "XOffset": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> XOffset: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> XOffset: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> XOffset: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> XOffset: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "XOffset": ...
+    ) -> XOffset: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -69097,8 +30285,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -69113,82 +30301,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(XOffset, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -69324,533 +30443,92 @@ class XOffsetDatum(DatumChannelMixin, core.ScaleDatumDef):
     _encoding_name = "xOffset"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "XOffsetDatum": ...
+    def bandPosition(self, _: float, **kwds) -> XOffsetDatum: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "XOffsetDatum": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "XOffsetDatum": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "XOffsetDatum": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "XOffsetDatum": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "XOffsetDatum": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> XOffsetDatum: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> XOffsetDatum: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> XOffsetDatum: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> XOffsetDatum: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> XOffsetDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "XOffsetDatum": ...
+    ) -> XOffsetDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(XOffsetDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             scale=scale,
@@ -69879,7 +30557,7 @@ class XOffsetValue(ValueChannelMixin, core.ValueDefnumber):
     _encoding_name = "xOffset"
 
     def __init__(self, value, **kwds):
-        super(XOffsetValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -70171,1677 +30849,262 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Y": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Y: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Y": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Y: ...
 
     @overload
     def axis(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandPosition: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[bool, UndefinedType] = Undefined,
-        domainCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        domainColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        domainDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        grid: Union[bool, UndefinedType] = Undefined,
-        gridCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        gridColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gridDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        gridDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelBound: Union[
-            bool, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFlush: Union[bool, float, UndefinedType] = Undefined,
-        labelFlushOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        maxExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "bottom", "left", "right"],
-            UndefinedType,
-        ] = Undefined,
-        position: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tickBand: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["center", "extent"],
-            UndefinedType,
-        ] = Undefined,
-        tickCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        tickColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        tickDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickExtra: Union[bool, UndefinedType] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickRound: Union[bool, UndefinedType] = Undefined,
-        tickSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ticks: Union[bool, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        translate: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Y": ...
-
-    @overload
-    def axis(self, _: None, **kwds) -> "Y": ...
-
-    @overload
-    def bandPosition(self, _: float, **kwds) -> "Y": ...
-
-    @overload
-    def bin(self, _: bool, **kwds) -> "Y": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandPosition: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        domain: Optional[bool] = Undefined,
+        domainCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        domainColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        domainDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        domainDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        grid: Optional[bool] = Undefined,
+        gridCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        gridColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gridDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        gridDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelBound: Optional[bool | dict | float | Parameter | SchemaBase] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFlush: Optional[bool | float] = Undefined,
+        labelFlushOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        maxExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | AxisOrient_T] = Undefined,
+        position: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tickBand: Optional[
+            dict | Parameter | SchemaBase | Literal["center", "extent"]
+        ] = Undefined,
+        tickCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        tickColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        tickDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickExtra: Optional[bool] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickRound: Optional[bool] = Undefined,
+        tickSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ticks: Optional[bool] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> Y: ...
+
+    @overload
+    def axis(self, _: None, **kwds) -> Y: ...
+
+    @overload
+    def bandPosition(self, _: float, **kwds) -> Y: ...
+
+    @overload
+    def bin(self, _: bool, **kwds) -> Y: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
-    def bin(self, _: str, **kwds) -> "Y": ...
+    def bin(self, _: str, **kwds) -> Y: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Y": ...
+    def bin(self, _: None, **kwds) -> Y: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Y": ...
+    def field(self, _: str, **kwds) -> Y: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def impute(
         self,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        keyvals: Union[dict, Sequence[Any], core.SchemaBase, UndefinedType] = Undefined,
-        method: Union[
-            core.SchemaBase,
-            Literal["value", "median", "max", "min", "mean"],
-            UndefinedType,
-        ] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        keyvals: Optional[dict | SchemaBase | Sequence[Any]] = Undefined,
+        method: Optional[SchemaBase | ImputeMethod_T] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
-    def impute(self, _: None, **kwds) -> "Y": ...
+    def impute(self, _: None, **kwds) -> Y: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Y": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "Y": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "Y": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "Y": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "Y": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "Y": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "Y": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> Y: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> Y: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> Y: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> Y: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> Y: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> Y: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> Y: ...
 
     @overload
     def sort(
@@ -71861,7 +31124,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def sort(
@@ -71881,85 +31144,36 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "Y": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> Y: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "Y": ...
+    def sort(self, _: None, **kwds) -> Y: ...
 
     @overload
-    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> "Y": ...
+    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> Y: ...
 
     @overload
-    def stack(self, _: None, **kwds) -> "Y": ...
+    def stack(self, _: None, **kwds) -> Y: ...
 
     @overload
-    def stack(self, _: bool, **kwds) -> "Y": ...
+    def stack(self, _: bool, **kwds) -> Y: ...
 
     @overload
     def timeUnit(
@@ -71978,7 +31192,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def timeUnit(
@@ -71997,7 +31211,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def timeUnit(
@@ -72034,7 +31248,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def timeUnit(
@@ -72071,7 +31285,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def timeUnit(
@@ -72093,7 +31307,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def timeUnit(
@@ -72115,241 +31329,70 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Y": ...
+    ) -> Y: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Y": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Y": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Y": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Y": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Y: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Y: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Y: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Y: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "Y": ...
+    ) -> Y: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        axis: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        impute: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        axis: Optional[dict | None | SchemaBase] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        impute: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -72364,8 +31407,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -72380,82 +31423,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(Y, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             axis=axis,
@@ -72644,1659 +31618,236 @@ class YDatum(DatumChannelMixin, core.PositionDatumDef):
     @overload
     def axis(
         self,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandPosition: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[bool, UndefinedType] = Undefined,
-        domainCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        domainColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        domainDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        grid: Union[bool, UndefinedType] = Undefined,
-        gridCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        gridColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gridDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        gridDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        gridWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelBound: Union[
-            bool, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFlush: Union[bool, float, UndefinedType] = Undefined,
-        labelFlushOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        maxExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minExtent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "bottom", "left", "right"],
-            UndefinedType,
-        ] = Undefined,
-        position: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tickBand: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["center", "extent"],
-            UndefinedType,
-        ] = Undefined,
-        tickCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        tickColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        tickDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickExtra: Union[bool, UndefinedType] = Undefined,
-        tickMinStep: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickRound: Union[bool, UndefinedType] = Undefined,
-        tickSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        tickWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ticks: Union[bool, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleAlign: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleX: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        titleY: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        translate: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        values: Union[
-            dict,
-            Sequence[str],
-            Sequence[bool],
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[float],
-            Sequence[Union[dict, core.SchemaBase]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "YDatum": ...
-
-    @overload
-    def axis(self, _: None, **kwds) -> "YDatum": ...
-
-    @overload
-    def bandPosition(self, _: float, **kwds) -> "YDatum": ...
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandPosition: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        domain: Optional[bool] = Undefined,
+        domainCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        domainColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        domainDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        domainDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        grid: Optional[bool] = Undefined,
+        gridCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        gridColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        gridDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        gridDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        labelBound: Optional[bool | dict | float | Parameter | SchemaBase] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFlush: Optional[bool | float] = Undefined,
+        labelFlushOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        maxExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | AxisOrient_T] = Undefined,
+        position: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tickBand: Optional[
+            dict | Parameter | SchemaBase | Literal["center", "extent"]
+        ] = Undefined,
+        tickCap: Optional[dict | Parameter | SchemaBase | StrokeCap_T] = Undefined,
+        tickColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        tickDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickExtra: Optional[bool] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickRound: Optional[bool] = Undefined,
+        tickSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ticks: Optional[bool] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Parameter | Baseline_T | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | SchemaBase | ColorName_T
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
+        **kwds,
+    ) -> YDatum: ...
+
+    @overload
+    def axis(self, _: None, **kwds) -> YDatum: ...
+
+    @overload
+    def bandPosition(self, _: float, **kwds) -> YDatum: ...
 
     @overload
     def impute(
         self,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        keyvals: Union[dict, Sequence[Any], core.SchemaBase, UndefinedType] = Undefined,
-        method: Union[
-            core.SchemaBase,
-            Literal["value", "median", "max", "min", "mean"],
-            UndefinedType,
-        ] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        keyvals: Optional[dict | SchemaBase | Sequence[Any]] = Undefined,
+        method: Optional[SchemaBase | ImputeMethod_T] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
-    ) -> "YDatum": ...
+    ) -> YDatum: ...
 
     @overload
-    def impute(self, _: None, **kwds) -> "YDatum": ...
+    def impute(self, _: None, **kwds) -> YDatum: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "YDatum": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "YDatum": ...
-
-    @overload
-    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> "YDatum": ...
-
-    @overload
-    def stack(self, _: None, **kwds) -> "YDatum": ...
-
-    @overload
-    def stack(self, _: bool, **kwds) -> "YDatum": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "YDatum": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "YDatum": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "YDatum": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> YDatum: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> YDatum: ...
+
+    @overload
+    def stack(self, _: Literal["zero", "center", "normalize"], **kwds) -> YDatum: ...
+
+    @overload
+    def stack(self, _: None, **kwds) -> YDatum: ...
+
+    @overload
+    def stack(self, _: bool, **kwds) -> YDatum: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> YDatum: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> YDatum: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> YDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "YDatum": ...
+    ) -> YDatum: ...
 
     def __init__(
         self,
         datum,
-        axis: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        impute: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            core.SchemaBase,
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        axis: Optional[dict | None | SchemaBase] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        impute: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(YDatum, self).__init__(
+        super().__init__(
             datum=datum,
             axis=axis,
             bandPosition=bandPosition,
@@ -74328,7 +31879,7 @@ class YValue(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "y"
 
     def __init__(self, value, **kwds):
-        super(YValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -74453,35 +32004,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Y2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Y2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "Y2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> Y2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Y2": ...
+    def bandPosition(self, _: float, **kwds) -> Y2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "Y2": ...
+    def bin(self, _: None, **kwds) -> Y2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "Y2": ...
+    def field(self, _: str, **kwds) -> Y2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
@@ -74500,7 +32049,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
@@ -74519,7 +32068,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
@@ -74556,7 +32105,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
@@ -74593,7 +32142,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
@@ -74615,7 +32164,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
@@ -74637,187 +32186,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "Y2": ...
+    ) -> Y2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "Y2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "Y2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "Y2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "Y2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> Y2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> Y2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> Y2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> Y2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -74832,8 +32243,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -74848,77 +32259,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(Y2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -75038,39 +32384,33 @@ class Y2Datum(DatumChannelMixin, core.DatumDef):
     _encoding_name = "y2"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "Y2Datum": ...
+    def bandPosition(self, _: float, **kwds) -> Y2Datum: ...
 
     @overload
-    def title(self, _: str, **kwds) -> "Y2Datum": ...
+    def title(self, _: str, **kwds) -> Y2Datum: ...
 
     @overload
-    def title(self, _: List[str], **kwds) -> "Y2Datum": ...
+    def title(self, _: list[str], **kwds) -> Y2Datum: ...
 
     @overload
-    def title(self, _: None, **kwds) -> "Y2Datum": ...
+    def title(self, _: None, **kwds) -> Y2Datum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "Y2Datum": ...
+    ) -> Y2Datum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Y2Datum, self).__init__(
+        super().__init__(
             datum=datum, bandPosition=bandPosition, title=title, type=type, **kwds
         )
 
@@ -75094,7 +32434,7 @@ class Y2Value(ValueChannelMixin, core.PositionValueDef):
     _encoding_name = "y2"
 
     def __init__(self, value, **kwds):
-        super(Y2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -75219,35 +32559,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "YError": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> YError: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "YError": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> YError: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "YError": ...
+    def bandPosition(self, _: float, **kwds) -> YError: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "YError": ...
+    def bin(self, _: None, **kwds) -> YError: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "YError": ...
+    def field(self, _: str, **kwds) -> YError: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
@@ -75266,7 +32604,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
@@ -75285,7 +32623,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
@@ -75322,7 +32660,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
@@ -75359,7 +32697,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
@@ -75381,7 +32719,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
@@ -75403,187 +32741,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "YError": ...
+    ) -> YError: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "YError": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "YError": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "YError": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "YError": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> YError: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> YError: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> YError: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> YError: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -75598,8 +32798,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -75614,77 +32814,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(YError, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -75715,7 +32850,7 @@ class YErrorValue(ValueChannelMixin, core.ValueDefnumber):
     _encoding_name = "yError"
 
     def __init__(self, value, **kwds):
-        super(YErrorValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -75840,35 +32975,33 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "YError2": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> YError2: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "YError2": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> YError2: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "YError2": ...
+    def bandPosition(self, _: float, **kwds) -> YError2: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "YError2": ...
+    def bin(self, _: None, **kwds) -> YError2: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "YError2": ...
+    def field(self, _: str, **kwds) -> YError2: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
@@ -75887,7 +33020,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
@@ -75906,7 +33039,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
@@ -75943,7 +33076,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
@@ -75980,7 +33113,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
@@ -76002,7 +33135,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
@@ -76024,187 +33157,49 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "YError2": ...
+    ) -> YError2: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "YError2": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "YError2": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "YError2": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "YError2": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> YError2: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> YError2: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> YError2: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> YError2: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -76219,8 +33214,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -76235,77 +33230,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(YError2, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -76336,7 +33266,7 @@ class YError2Value(ValueChannelMixin, core.ValueDefnumber):
     _encoding_name = "yError2"
 
     def __init__(self, value, **kwds):
-        super(YError2Value, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 @with_property_setters
@@ -76580,564 +33510,125 @@ def aggregate(
             "exponentialb",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def aggregate(
-        self, argmax: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "YOffset": ...
+        self, argmax: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> YOffset: ...
 
     @overload
     def aggregate(
-        self, argmin: Union[str, core.SchemaBase, UndefinedType] = Undefined, **kwds
-    ) -> "YOffset": ...
+        self, argmin: Optional[str | SchemaBase] = Undefined, **kwds
+    ) -> YOffset: ...
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "YOffset": ...
+    def bandPosition(self, _: float, **kwds) -> YOffset: ...
 
     @overload
-    def bin(self, _: bool, **kwds) -> "YOffset": ...
+    def bin(self, _: bool, **kwds) -> YOffset: ...
 
     @overload
     def bin(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
-    def bin(self, _: None, **kwds) -> "YOffset": ...
+    def bin(self, _: None, **kwds) -> YOffset: ...
 
     @overload
-    def field(self, _: str, **kwds) -> "YOffset": ...
+    def field(self, _: str, **kwds) -> YOffset: ...
 
     @overload
     def field(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "YOffset": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "YOffset": ...
-
-    @overload
-    def sort(self, _: List[float], **kwds) -> "YOffset": ...
-
-    @overload
-    def sort(self, _: List[str], **kwds) -> "YOffset": ...
-
-    @overload
-    def sort(self, _: List[bool], **kwds) -> "YOffset": ...
-
-    @overload
-    def sort(self, _: List[core.DateTime], **kwds) -> "YOffset": ...
-
-    @overload
-    def sort(self, _: Literal["ascending", "descending"], **kwds) -> "YOffset": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> YOffset: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> YOffset: ...
+
+    @overload
+    def sort(self, _: list[float], **kwds) -> YOffset: ...
+
+    @overload
+    def sort(self, _: list[str], **kwds) -> YOffset: ...
+
+    @overload
+    def sort(self, _: list[bool], **kwds) -> YOffset: ...
+
+    @overload
+    def sort(self, _: list[core.DateTime], **kwds) -> YOffset: ...
+
+    @overload
+    def sort(self, _: Literal["ascending", "descending"], **kwds) -> YOffset: ...
 
     @overload
     def sort(
@@ -77157,7 +33648,7 @@ def sort(
             "text",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def sort(
@@ -77177,76 +33668,27 @@ def sort(
             "-text",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def sort(
         self,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        op: Union[
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "YOffset": ...
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
+        **kwds,
+    ) -> YOffset: ...
 
     @overload
     def sort(
         self,
-        encoding: Union[
-            core.SchemaBase,
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, core.SchemaBase, Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SchemaBase | SortOrder_T] = Undefined,
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
-    def sort(self, _: None, **kwds) -> "YOffset": ...
+    def sort(self, _: None, **kwds) -> YOffset: ...
 
     @overload
     def timeUnit(
@@ -77265,7 +33707,7 @@ def timeUnit(
             "milliseconds",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def timeUnit(
@@ -77284,7 +33726,7 @@ def timeUnit(
             "utcmilliseconds",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def timeUnit(
@@ -77321,7 +33763,7 @@ def timeUnit(
             "secondsmilliseconds",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def timeUnit(
@@ -77358,7 +33800,7 @@ def timeUnit(
             "utcsecondsmilliseconds",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def timeUnit(
@@ -77380,7 +33822,7 @@ def timeUnit(
             "binnedyeardayofyear",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def timeUnit(
@@ -77402,232 +33844,67 @@ def timeUnit(
             "binnedutcyeardayofyear",
         ],
         **kwds,
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     @overload
     def timeUnit(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        **kwds,
-    ) -> "YOffset": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "YOffset": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "YOffset": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "YOffset": ...
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
+        **kwds,
+    ) -> YOffset: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> YOffset: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> YOffset: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> YOffset: ...
 
     @overload
     def type(
         self, _: Literal["quantitative", "ordinal", "temporal", "nominal"], **kwds
-    ) -> "YOffset": ...
+    ) -> YOffset: ...
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        field: Union[str, dict, core.SchemaBase, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            Sequence[str],
-            Sequence[bool],
-            core.SchemaBase,
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, core.SchemaBase]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            core.SchemaBase,
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SchemaBase
+            | SortOrder_T
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -77642,8 +33919,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -77658,82 +33935,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(YOffset, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -77869,533 +34077,92 @@ class YOffsetDatum(DatumChannelMixin, core.ScaleDatumDef):
     _encoding_name = "yOffset"
 
     @overload
-    def bandPosition(self, _: float, **kwds) -> "YOffsetDatum": ...
+    def bandPosition(self, _: float, **kwds) -> YOffsetDatum: ...
 
     @overload
     def scale(
         self,
-        align: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        base: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bins: Union[dict, core.SchemaBase, Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        constant: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Sequence[
-                Union[str, bool, dict, None, float, core._Parameter, core.SchemaBase]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        domainRaw: Union[
-            dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        exponent: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            core.SchemaBase,
-            Sequence[
-                Union[
-                    str, dict, float, core._Parameter, core.SchemaBase, Sequence[float]
-                ]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        round: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        scheme: Union[
-            dict,
-            Sequence[str],
-            core._Parameter,
-            core.SchemaBase,
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        **kwds,
-    ) -> "YOffsetDatum": ...
-
-    @overload
-    def scale(self, _: None, **kwds) -> "YOffsetDatum": ...
-
-    @overload
-    def title(self, _: str, **kwds) -> "YOffsetDatum": ...
-
-    @overload
-    def title(self, _: List[str], **kwds) -> "YOffsetDatum": ...
-
-    @overload
-    def title(self, _: None, **kwds) -> "YOffsetDatum": ...
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | SchemaBase
+            | RangeEnum_T
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Parameter
+            | Cyclical_T
+            | SchemaBase
+            | Diverging_T
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[SchemaBase | ScaleType_T] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        **kwds,
+    ) -> YOffsetDatum: ...
+
+    @overload
+    def scale(self, _: None, **kwds) -> YOffsetDatum: ...
+
+    @overload
+    def title(self, _: str, **kwds) -> YOffsetDatum: ...
+
+    @overload
+    def title(self, _: list[str], **kwds) -> YOffsetDatum: ...
+
+    @overload
+    def title(self, _: None, **kwds) -> YOffsetDatum: ...
 
     @overload
     def type(
         self,
         _: Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
         **kwds,
-    ) -> "YOffsetDatum": ...
+    ) -> YOffsetDatum: ...
 
     def __init__(
         self,
         datum,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        scale: Union[dict, None, core.SchemaBase, UndefinedType] = Undefined,
-        title: Union[
-            str, None, Sequence[str], core.SchemaBase, UndefinedType
-        ] = Undefined,
-        type: Union[
-            core.SchemaBase,
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(YOffsetDatum, self).__init__(
+        super().__init__(
             datum=datum,
             bandPosition=bandPosition,
             scale=scale,
@@ -78424,79 +34191,63 @@ class YOffsetValue(ValueChannelMixin, core.ValueDefnumber):
     _encoding_name = "yOffset"
 
     def __init__(self, value, **kwds):
-        super(YOffsetValue, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 def _encode_signature(
     self,
-    angle: Union[str, Angle, dict, AngleDatum, AngleValue, UndefinedType] = Undefined,
-    color: Union[str, Color, dict, ColorDatum, ColorValue, UndefinedType] = Undefined,
-    column: Union[str, Column, dict, UndefinedType] = Undefined,
-    description: Union[
-        str, Description, dict, DescriptionValue, UndefinedType
-    ] = Undefined,
-    detail: Union[str, Detail, dict, list, UndefinedType] = Undefined,
-    facet: Union[str, Facet, dict, UndefinedType] = Undefined,
-    fill: Union[str, Fill, dict, FillDatum, FillValue, UndefinedType] = Undefined,
-    fillOpacity: Union[
-        str, FillOpacity, dict, FillOpacityDatum, FillOpacityValue, UndefinedType
-    ] = Undefined,
-    href: Union[str, Href, dict, HrefValue, UndefinedType] = Undefined,
-    key: Union[str, Key, dict, UndefinedType] = Undefined,
-    latitude: Union[str, Latitude, dict, LatitudeDatum, UndefinedType] = Undefined,
-    latitude2: Union[
-        str, Latitude2, dict, Latitude2Datum, Latitude2Value, UndefinedType
-    ] = Undefined,
-    longitude: Union[str, Longitude, dict, LongitudeDatum, UndefinedType] = Undefined,
-    longitude2: Union[
-        str, Longitude2, dict, Longitude2Datum, Longitude2Value, UndefinedType
-    ] = Undefined,
-    opacity: Union[
-        str, Opacity, dict, OpacityDatum, OpacityValue, UndefinedType
-    ] = Undefined,
-    order: Union[str, Order, dict, list, OrderValue, UndefinedType] = Undefined,
-    radius: Union[
-        str, Radius, dict, RadiusDatum, RadiusValue, UndefinedType
-    ] = Undefined,
-    radius2: Union[
-        str, Radius2, dict, Radius2Datum, Radius2Value, UndefinedType
-    ] = Undefined,
-    row: Union[str, Row, dict, UndefinedType] = Undefined,
-    shape: Union[str, Shape, dict, ShapeDatum, ShapeValue, UndefinedType] = Undefined,
-    size: Union[str, Size, dict, SizeDatum, SizeValue, UndefinedType] = Undefined,
-    stroke: Union[
-        str, Stroke, dict, StrokeDatum, StrokeValue, UndefinedType
-    ] = Undefined,
-    strokeDash: Union[
-        str, StrokeDash, dict, StrokeDashDatum, StrokeDashValue, UndefinedType
+    angle: Optional[str | Angle | dict | AngleDatum | AngleValue] = Undefined,
+    color: Optional[str | Color | dict | ColorDatum | ColorValue] = Undefined,
+    column: Optional[str | Column | dict] = Undefined,
+    description: Optional[str | Description | dict | DescriptionValue] = Undefined,
+    detail: Optional[str | Detail | dict | list] = Undefined,
+    facet: Optional[str | Facet | dict] = Undefined,
+    fill: Optional[str | Fill | dict | FillDatum | FillValue] = Undefined,
+    fillOpacity: Optional[
+        str | FillOpacity | dict | FillOpacityDatum | FillOpacityValue
     ] = Undefined,
-    strokeOpacity: Union[
-        str, StrokeOpacity, dict, StrokeOpacityDatum, StrokeOpacityValue, UndefinedType
+    href: Optional[str | Href | dict | HrefValue] = Undefined,
+    key: Optional[str | Key | dict] = Undefined,
+    latitude: Optional[str | Latitude | dict | LatitudeDatum] = Undefined,
+    latitude2: Optional[
+        str | Latitude2 | dict | Latitude2Datum | Latitude2Value
     ] = Undefined,
-    strokeWidth: Union[
-        str, StrokeWidth, dict, StrokeWidthDatum, StrokeWidthValue, UndefinedType
+    longitude: Optional[str | Longitude | dict | LongitudeDatum] = Undefined,
+    longitude2: Optional[
+        str | Longitude2 | dict | Longitude2Datum | Longitude2Value
     ] = Undefined,
-    text: Union[str, Text, dict, TextDatum, TextValue, UndefinedType] = Undefined,
-    theta: Union[str, Theta, dict, ThetaDatum, ThetaValue, UndefinedType] = Undefined,
-    theta2: Union[
-        str, Theta2, dict, Theta2Datum, Theta2Value, UndefinedType
+    opacity: Optional[str | Opacity | dict | OpacityDatum | OpacityValue] = Undefined,
+    order: Optional[str | Order | dict | list | OrderValue] = Undefined,
+    radius: Optional[str | Radius | dict | RadiusDatum | RadiusValue] = Undefined,
+    radius2: Optional[str | Radius2 | dict | Radius2Datum | Radius2Value] = Undefined,
+    row: Optional[str | Row | dict] = Undefined,
+    shape: Optional[str | Shape | dict | ShapeDatum | ShapeValue] = Undefined,
+    size: Optional[str | Size | dict | SizeDatum | SizeValue] = Undefined,
+    stroke: Optional[str | Stroke | dict | StrokeDatum | StrokeValue] = Undefined,
+    strokeDash: Optional[
+        str | StrokeDash | dict | StrokeDashDatum | StrokeDashValue
     ] = Undefined,
-    tooltip: Union[str, Tooltip, dict, list, TooltipValue, UndefinedType] = Undefined,
-    url: Union[str, Url, dict, UrlValue, UndefinedType] = Undefined,
-    x: Union[str, X, dict, XDatum, XValue, UndefinedType] = Undefined,
-    x2: Union[str, X2, dict, X2Datum, X2Value, UndefinedType] = Undefined,
-    xError: Union[str, XError, dict, XErrorValue, UndefinedType] = Undefined,
-    xError2: Union[str, XError2, dict, XError2Value, UndefinedType] = Undefined,
-    xOffset: Union[
-        str, XOffset, dict, XOffsetDatum, XOffsetValue, UndefinedType
+    strokeOpacity: Optional[
+        str | StrokeOpacity | dict | StrokeOpacityDatum | StrokeOpacityValue
     ] = Undefined,
-    y: Union[str, Y, dict, YDatum, YValue, UndefinedType] = Undefined,
-    y2: Union[str, Y2, dict, Y2Datum, Y2Value, UndefinedType] = Undefined,
-    yError: Union[str, YError, dict, YErrorValue, UndefinedType] = Undefined,
-    yError2: Union[str, YError2, dict, YError2Value, UndefinedType] = Undefined,
-    yOffset: Union[
-        str, YOffset, dict, YOffsetDatum, YOffsetValue, UndefinedType
+    strokeWidth: Optional[
+        str | StrokeWidth | dict | StrokeWidthDatum | StrokeWidthValue
     ] = Undefined,
+    text: Optional[str | Text | dict | TextDatum | TextValue] = Undefined,
+    theta: Optional[str | Theta | dict | ThetaDatum | ThetaValue] = Undefined,
+    theta2: Optional[str | Theta2 | dict | Theta2Datum | Theta2Value] = Undefined,
+    tooltip: Optional[str | Tooltip | dict | list | TooltipValue] = Undefined,
+    url: Optional[str | Url | dict | UrlValue] = Undefined,
+    x: Optional[str | X | dict | XDatum | XValue] = Undefined,
+    x2: Optional[str | X2 | dict | X2Datum | X2Value] = Undefined,
+    xError: Optional[str | XError | dict | XErrorValue] = Undefined,
+    xError2: Optional[str | XError2 | dict | XError2Value] = Undefined,
+    xOffset: Optional[str | XOffset | dict | XOffsetDatum | XOffsetValue] = Undefined,
+    y: Optional[str | Y | dict | YDatum | YValue] = Undefined,
+    y2: Optional[str | Y2 | dict | Y2Datum | Y2Value] = Undefined,
+    yError: Optional[str | YError | dict | YErrorValue] = Undefined,
+    yError2: Optional[str | YError2 | dict | YError2Value] = Undefined,
+    yOffset: Optional[str | YOffset | dict | YOffsetDatum | YOffsetValue] = Undefined,
 ):
     """Parameters
     ----------
@@ -78504,7 +34255,7 @@ def _encode_signature(
     angle : str, :class:`Angle`, Dict, :class:`AngleDatum`, :class:`AngleValue`
         Rotation angle of point and text marks.
     color : str, :class:`Color`, Dict, :class:`ColorDatum`, :class:`ColorValue`
-        Color of the marks – either fill or stroke color based on  the ``filled`` property
+        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"``.
@@ -78547,7 +34298,7 @@ def _encode_signature(
     href : str, :class:`Href`, Dict, :class:`HrefValue`
         A URL to load upon mouse click.
     key : str, :class:`Key`, Dict
-        A data field to use as a unique key for data binding. When a visualization’s data is
+        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.
@@ -78612,10 +34363,10 @@ def _encode_signature(
         Size of the mark.
 
 
-        * For ``"point"``, ``"square"`` and ``"circle"``, – the symbol size, or pixel area
+        * 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.
+        * 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 : str, :class:`Stroke`, Dict, :class:`StrokeDatum`, :class:`StrokeValue`
@@ -78699,4 +34450,3 @@ def _encode_signature(
     yOffset : str, :class:`YOffset`, Dict, :class:`YOffsetDatum`, :class:`YOffsetValue`
         Offset of y-position of the marks
     """
-    ...
diff --git a/altair/vegalite/v5/schema/core.py b/altair/vegalite/v5/schema/core.py
index 05909a3b2..38bc0868a 100644
--- a/altair/vegalite/v5/schema/core.py
+++ b/altair/vegalite/v5/schema/core.py
@@ -1,7 +1,29 @@
 # The contents of this file are automatically written by
 # tools/generate_schema_wrapper.py. Do not modify directly.
 
+from __future__ import annotations
+
+import json
+import pkgutil
+from typing import TYPE_CHECKING, Any, Iterator, Literal, Sequence
+
+from altair.utils.schemapi import (  # noqa: F401
+    SchemaBase,
+    Undefined,
+    UndefinedType,
+    _subclasses,
+)
+
+# ruff: noqa: F405
+if TYPE_CHECKING:
+    from altair import Parameter
+    from altair.utils.schemapi import Optional
+
+    from ._typing import *  # noqa: F403
+
+
 __all__ = [
+    "URI",
     "Aggregate",
     "AggregateOp",
     "AggregateTransform",
@@ -43,20 +65,10 @@
     "ColorDef",
     "ColorName",
     "ColorScheme",
-    "Encoding",
     "CompositeMark",
     "CompositeMarkDef",
     "CompositionConfig",
-    "ConditionalMarkPropFieldOrDatumDef",
-    "ConditionalMarkPropFieldOrDatumDefTypeForShape",
-    "ConditionalStringFieldDef",
-    "ConditionalValueDefGradientstringnullExprRef",
-    "ConditionalValueDefTextExprRef",
-    "ConditionalValueDefnumberArrayExprRef",
-    "ConditionalValueDefnumberExprRef",
-    "ConditionalValueDefstringExprRef",
-    "ConditionalValueDefstringnullExprRef",
-    "ConditionalValueDefnumber",
+    "ConcatSpecGenericSpec",
     "ConditionalAxisColor",
     "ConditionalAxisLabelAlign",
     "ConditionalAxisLabelBaseline",
@@ -73,33 +85,43 @@
     "ConditionalAxisPropertynumbernull",
     "ConditionalAxisPropertystringnull",
     "ConditionalAxisString",
+    "ConditionalMarkPropFieldOrDatumDef",
+    "ConditionalMarkPropFieldOrDatumDefTypeForShape",
     "ConditionalParameterMarkPropFieldOrDatumDef",
     "ConditionalParameterMarkPropFieldOrDatumDefTypeForShape",
     "ConditionalParameterStringFieldDef",
     "ConditionalParameterValueDefGradientstringnullExprRef",
     "ConditionalParameterValueDefTextExprRef",
+    "ConditionalParameterValueDefnumber",
     "ConditionalParameterValueDefnumberArrayExprRef",
     "ConditionalParameterValueDefnumberExprRef",
     "ConditionalParameterValueDefstringExprRef",
     "ConditionalParameterValueDefstringnullExprRef",
-    "ConditionalParameterValueDefnumber",
+    "ConditionalPredicateMarkPropFieldOrDatumDef",
+    "ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape",
+    "ConditionalPredicateStringFieldDef",
     "ConditionalPredicateValueDefAlignnullExprRef",
     "ConditionalPredicateValueDefColornullExprRef",
     "ConditionalPredicateValueDefFontStylenullExprRef",
     "ConditionalPredicateValueDefFontWeightnullExprRef",
-    "ConditionalPredicateValueDefTextBaselinenullExprRef",
-    "ConditionalPredicateValueDefnumberArraynullExprRef",
-    "ConditionalPredicateValueDefnumbernullExprRef",
-    "ConditionalPredicateValueDefstringnullExprRef",
-    "ConditionalPredicateMarkPropFieldOrDatumDef",
-    "ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape",
-    "ConditionalPredicateStringFieldDef",
     "ConditionalPredicateValueDefGradientstringnullExprRef",
+    "ConditionalPredicateValueDefTextBaselinenullExprRef",
     "ConditionalPredicateValueDefTextExprRef",
+    "ConditionalPredicateValueDefnumber",
     "ConditionalPredicateValueDefnumberArrayExprRef",
+    "ConditionalPredicateValueDefnumberArraynullExprRef",
     "ConditionalPredicateValueDefnumberExprRef",
+    "ConditionalPredicateValueDefnumbernullExprRef",
     "ConditionalPredicateValueDefstringExprRef",
-    "ConditionalPredicateValueDefnumber",
+    "ConditionalPredicateValueDefstringnullExprRef",
+    "ConditionalStringFieldDef",
+    "ConditionalValueDefGradientstringnullExprRef",
+    "ConditionalValueDefTextExprRef",
+    "ConditionalValueDefnumber",
+    "ConditionalValueDefnumberArrayExprRef",
+    "ConditionalValueDefnumberExprRef",
+    "ConditionalValueDefstringExprRef",
+    "ConditionalValueDefstringnullExprRef",
     "Config",
     "CsvDataFormat",
     "Cursor",
@@ -113,14 +135,15 @@
     "Day",
     "DensityTransform",
     "DerivedStream",
+    "Dict",
     "DictInlineDataset",
     "DictSelectionInit",
     "DictSelectionInitInterval",
-    "Dict",
     "Diverging",
     "DomainUnionWith",
     "DsvDataFormat",
     "Element",
+    "Encoding",
     "EncodingSortField",
     "ErrorBand",
     "ErrorBandConfig",
@@ -137,11 +160,12 @@
     "FacetEncodingFieldDef",
     "FacetFieldDef",
     "FacetMapping",
+    "FacetSpec",
     "FacetedEncoding",
     "FacetedUnitSpec",
     "Feature",
-    "FeatureGeometryGeoJsonProperties",
     "FeatureCollection",
+    "FeatureGeometryGeoJsonProperties",
     "Field",
     "FieldDefWithoutScale",
     "FieldEqualPredicate",
@@ -152,13 +176,13 @@
     "FieldName",
     "FieldOneOfPredicate",
     "FieldOrDatumDefWithConditionDatumDefGradientstringnull",
-    "FieldOrDatumDefWithConditionDatumDefstringnull",
     "FieldOrDatumDefWithConditionDatumDefnumber",
     "FieldOrDatumDefWithConditionDatumDefnumberArray",
+    "FieldOrDatumDefWithConditionDatumDefstringnull",
     "FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull",
+    "FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull",
     "FieldOrDatumDefWithConditionMarkPropFieldDefnumber",
     "FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray",
-    "FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull",
     "FieldOrDatumDefWithConditionStringDatumDefText",
     "FieldOrDatumDefWithConditionStringFieldDefText",
     "FieldOrDatumDefWithConditionStringFieldDefstring",
@@ -173,12 +197,7 @@
     "FontWeight",
     "FormatConfig",
     "Generator",
-    "ConcatSpecGenericSpec",
-    "FacetSpec",
-    "HConcatSpecGenericSpec",
-    "Spec",
     "GenericUnitSpecEncodingAnyMark",
-    "VConcatSpecGenericSpec",
     "GeoJsonFeature",
     "GeoJsonFeatureCollection",
     "GeoJsonProperties",
@@ -188,6 +207,7 @@
     "GradientStop",
     "GraticuleGenerator",
     "GraticuleParams",
+    "HConcatSpecGenericSpec",
     "Header",
     "HeaderConfig",
     "HexColor",
@@ -224,7 +244,6 @@
     "Locale",
     "LoessTransform",
     "LogicalAndPredicate",
-    "PredicateComposition",
     "LogicalNotPredicate",
     "LogicalOrPredicate",
     "LookupData",
@@ -234,9 +253,9 @@
     "MarkConfig",
     "MarkDef",
     "MarkPropDefGradientstringnull",
-    "MarkPropDefstringnullTypeForShape",
     "MarkPropDefnumber",
     "MarkPropDefnumberArray",
+    "MarkPropDefstringnullTypeForShape",
     "MarkType",
     "MergedStream",
     "Month",
@@ -279,6 +298,7 @@
     "PositionFieldDefBase",
     "PositionValueDef",
     "Predicate",
+    "PredicateComposition",
     "PrimitiveValue",
     "Projection",
     "ProjectionConfig",
@@ -298,6 +318,7 @@
     "RepeatSpec",
     "Resolve",
     "ResolveMode",
+    "Root",
     "RowColLayoutAlign",
     "RowColboolean",
     "RowColnumber",
@@ -313,6 +334,7 @@
     "ScaleInterpolateParams",
     "ScaleResolveMap",
     "ScaleType",
+    "SchemaBase",
     "SchemeParams",
     "SecondaryFieldDef",
     "SelectionConfig",
@@ -338,6 +360,7 @@
     "SortByEncoding",
     "SortField",
     "SortOrder",
+    "Spec",
     "SphereGenerator",
     "StackOffset",
     "StackTransform",
@@ -371,37 +394,35 @@
     "TitleParams",
     "TooltipContent",
     "TopLevelConcatSpec",
+    "TopLevelFacetSpec",
     "TopLevelHConcatSpec",
-    "TopLevelVConcatSpec",
     "TopLevelLayerSpec",
-    "TopLevelRepeatSpec",
-    "TopLevelFacetSpec",
     "TopLevelParameter",
+    "TopLevelRepeatSpec",
     "TopLevelSelectionParameter",
     "TopLevelSpec",
     "TopLevelUnitSpec",
+    "TopLevelVConcatSpec",
     "TopoDataFormat",
     "Transform",
     "Type",
     "TypeForShape",
     "TypedFieldDef",
-    "URI",
     "UnitSpec",
     "UnitSpecWithFrame",
     "UrlData",
     "UtcMultiTimeUnit",
     "UtcSingleTimeUnit",
-    "ValueDefnumberwidthheightExprRef",
-    "ValueDefnumber",
+    "VConcatSpecGenericSpec",
     "ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull",
-    "ValueDefWithConditionMarkPropFieldOrDatumDefstringnull",
+    "ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull",
     "ValueDefWithConditionMarkPropFieldOrDatumDefnumber",
     "ValueDefWithConditionMarkPropFieldOrDatumDefnumberArray",
-    "ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull",
+    "ValueDefWithConditionMarkPropFieldOrDatumDefstringnull",
     "ValueDefWithConditionStringFieldDefText",
+    "ValueDefnumber",
+    "ValueDefnumberwidthheightExprRef",
     "VariableParameter",
-    "Vector10string",
-    "Vector12string",
     "Vector2DateTime",
     "Vector2Vector2number",
     "Vector2boolean",
@@ -409,56 +430,33 @@
     "Vector2string",
     "Vector3number",
     "Vector7string",
+    "Vector10string",
+    "Vector12string",
+    "VegaLiteSchema",
     "ViewBackground",
     "ViewConfig",
     "WindowEventType",
     "WindowFieldDef",
     "WindowOnlyOp",
     "WindowTransform",
-    "Root",
-    "VegaLiteSchema",
-    "SchemaBase",
     "load_schema",
 ]
-from typing import Any, Literal, Union, Protocol, Sequence, List
-from typing import Dict as TypingDict
-from typing import Generator as TypingGenerator
-from altair.utils.schemapi import SchemaBase, Undefined, UndefinedType, _subclasses
-
-import pkgutil
-import json
 
 
 def load_schema() -> dict:
     """Load the json schema associated with this module's functions"""
     schema_bytes = pkgutil.get_data(__name__, "vega-lite-schema.json")
     if schema_bytes is None:
-        raise ValueError("Unable to load vega-lite-schema.json")
+        msg = "Unable to load vega-lite-schema.json"
+        raise ValueError(msg)
     return json.loads(schema_bytes.decode("utf-8"))
 
 
-class _Parameter(Protocol):
-    # This protocol represents a Parameter as defined in api.py
-    # It would be better if we could directly use the Parameter class,
-    # but that would create a circular import.
-    # The protocol does not need to have all the attributes and methods of this
-    # class but the actual api.Parameter just needs to pass a type check
-    # as a core._Parameter.
-
-    _counter: int
-
-    def _get_name(cls) -> str: ...
-
-    def to_dict(self) -> TypingDict[str, Union[str, dict]]: ...
-
-    def _to_expr(self) -> str: ...
-
-
 class VegaLiteSchema(SchemaBase):
     _rootschema = load_schema()
 
     @classmethod
-    def _default_wrapper_classes(cls) -> TypingGenerator[type, None, None]:
+    def _default_wrapper_classes(cls) -> Iterator[type[Any]]:
         return _subclasses(VegaLiteSchema)
 
 
@@ -471,7 +469,7 @@ class Root(VegaLiteSchema):
     _schema = VegaLiteSchema._rootschema
 
     def __init__(self, *args, **kwds):
-        super(Root, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Aggregate(VegaLiteSchema):
@@ -480,7 +478,7 @@ class Aggregate(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Aggregate"}
 
     def __init__(self, *args, **kwds):
-        super(Aggregate, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class AggregateOp(VegaLiteSchema):
@@ -489,7 +487,7 @@ class AggregateOp(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/AggregateOp"}
 
     def __init__(self, *args):
-        super(AggregateOp, self).__init__(*args)
+        super().__init__(*args)
 
 
 class AggregatedFieldDef(VegaLiteSchema):
@@ -513,41 +511,11 @@ class AggregatedFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        op: Union[
-            "SchemaBase",
-            Literal[
-                "argmax",
-                "argmin",
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
+        op: Optional[SchemaBase | AggregateOp_T] = Undefined,
+        field: Optional[str | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(AggregatedFieldDef, self).__init__(op=op, field=field, **kwds)
+        super().__init__(op=op, field=field, **kwds)
 
 
 class Align(VegaLiteSchema):
@@ -556,7 +524,7 @@ class Align(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Align"}
 
     def __init__(self, *args):
-        super(Align, self).__init__(*args)
+        super().__init__(*args)
 
 
 class AnyMark(VegaLiteSchema):
@@ -565,7 +533,7 @@ class AnyMark(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/AnyMark"}
 
     def __init__(self, *args, **kwds):
-        super(AnyMark, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class AnyMarkConfig(VegaLiteSchema):
@@ -574,7 +542,7 @@ class AnyMarkConfig(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/AnyMarkConfig"}
 
     def __init__(self, *args, **kwds):
-        super(AnyMarkConfig, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class AreaConfig(AnyMarkConfig):
@@ -969,773 +937,100 @@ class AreaConfig(AnyMarkConfig):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(AreaConfig, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -1823,10 +1118,8 @@ class ArgmaxDef(Aggregate):
 
     _schema = {"$ref": "#/definitions/ArgmaxDef"}
 
-    def __init__(
-        self, argmax: Union[str, "SchemaBase", UndefinedType] = Undefined, **kwds
-    ):
-        super(ArgmaxDef, self).__init__(argmax=argmax, **kwds)
+    def __init__(self, argmax: Optional[str | SchemaBase] = Undefined, **kwds):
+        super().__init__(argmax=argmax, **kwds)
 
 
 class ArgminDef(Aggregate):
@@ -1841,10 +1134,8 @@ class ArgminDef(Aggregate):
 
     _schema = {"$ref": "#/definitions/ArgminDef"}
 
-    def __init__(
-        self, argmin: Union[str, "SchemaBase", UndefinedType] = Undefined, **kwds
-    ):
-        super(ArgminDef, self).__init__(argmin=argmin, **kwds)
+    def __init__(self, argmin: Optional[str | SchemaBase] = Undefined, **kwds):
+        super().__init__(argmin=argmin, **kwds)
 
 
 class AutoSizeParams(VegaLiteSchema):
@@ -1880,16 +1171,12 @@ class AutoSizeParams(VegaLiteSchema):
 
     def __init__(
         self,
-        contains: Union[Literal["content", "padding"], UndefinedType] = Undefined,
-        resize: Union[bool, UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase", Literal["pad", "none", "fit", "fit-x", "fit-y"], UndefinedType
-        ] = Undefined,
+        contains: Optional[Literal["content", "padding"]] = Undefined,
+        resize: Optional[bool] = Undefined,
+        type: Optional[SchemaBase | AutosizeType_T] = Undefined,
         **kwds,
     ):
-        super(AutoSizeParams, self).__init__(
-            contains=contains, resize=resize, type=type, **kwds
-        )
+        super().__init__(contains=contains, resize=resize, type=type, **kwds)
 
 
 class AutosizeType(VegaLiteSchema):
@@ -1898,7 +1185,7 @@ class AutosizeType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/AutosizeType"}
 
     def __init__(self, *args):
-        super(AutosizeType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Axis(VegaLiteSchema):
@@ -2280,1085 +1567,121 @@ class Axis(VegaLiteSchema):
 
     def __init__(
         self,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        bandPosition: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domain: Union[bool, UndefinedType] = Undefined,
-        domainCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        domainColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        domainDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        grid: Union[bool, UndefinedType] = Undefined,
-        gridCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        gridColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gridDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        gridDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gridOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gridWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelBound: Union[
-            bool, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFlush: Union[bool, float, UndefinedType] = Undefined,
-        labelFlushOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        maxExtent: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        minExtent: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "bottom", "left", "right"],
-            UndefinedType,
-        ] = Undefined,
-        position: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tickBand: Union[
-            dict, "_Parameter", "SchemaBase", Literal["center", "extent"], UndefinedType
-        ] = Undefined,
-        tickCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        tickColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        tickDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickExtra: Union[bool, UndefinedType] = Undefined,
-        tickMinStep: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickRound: Union[bool, UndefinedType] = Undefined,
-        tickSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ticks: Union[bool, UndefinedType] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        titleAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleX: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleY: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        translate: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        values: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandPosition: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        domain: Optional[bool] = Undefined,
+        domainCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        domainColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        domainDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        domainDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        grid: Optional[bool] = Undefined,
+        gridCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        gridColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        gridDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        gridDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        labelBound: Optional[bool | dict | float | Parameter | SchemaBase] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFlush: Optional[bool | float] = Undefined,
+        labelFlushOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        maxExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | AxisOrient_T] = Undefined,
+        position: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tickBand: Optional[
+            dict | Parameter | SchemaBase | Literal["center", "extent"]
+        ] = Undefined,
+        tickCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        tickColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        tickDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickExtra: Optional[bool] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickRound: Optional[bool] = Undefined,
+        tickSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ticks: Optional[bool] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
         **kwds,
     ):
-        super(Axis, self).__init__(
+        super().__init__(
             aria=aria,
             bandPosition=bandPosition,
             description=description,
@@ -3822,1086 +2145,122 @@ class AxisConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        bandPosition: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        disable: Union[bool, UndefinedType] = Undefined,
-        domain: Union[bool, UndefinedType] = Undefined,
-        domainCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        domainColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        domainDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        domainDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        grid: Union[bool, UndefinedType] = Undefined,
-        gridCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        gridColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gridDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        gridDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gridOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gridWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelBound: Union[
-            bool, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFlush: Union[bool, float, UndefinedType] = Undefined,
-        labelFlushOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        maxExtent: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        minExtent: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "bottom", "left", "right"],
-            UndefinedType,
-        ] = Undefined,
-        position: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tickBand: Union[
-            dict, "_Parameter", "SchemaBase", Literal["center", "extent"], UndefinedType
-        ] = Undefined,
-        tickCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        tickColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        tickDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickExtra: Union[bool, UndefinedType] = Undefined,
-        tickMinStep: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickRound: Union[bool, UndefinedType] = Undefined,
-        tickSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ticks: Union[bool, UndefinedType] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        titleAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleX: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleY: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        translate: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        values: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandPosition: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        disable: Optional[bool] = Undefined,
+        domain: Optional[bool] = Undefined,
+        domainCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        domainColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        domainDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        domainDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        grid: Optional[bool] = Undefined,
+        gridCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        gridColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        gridDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        gridDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        labelBound: Optional[bool | dict | float | Parameter | SchemaBase] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFlush: Optional[bool | float] = Undefined,
+        labelFlushOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        maxExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minExtent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | AxisOrient_T] = Undefined,
+        position: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tickBand: Optional[
+            dict | Parameter | SchemaBase | Literal["center", "extent"]
+        ] = Undefined,
+        tickCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        tickColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickDash: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        tickDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickExtra: Optional[bool] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickRound: Optional[bool] = Undefined,
+        tickSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tickWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ticks: Optional[bool] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
         **kwds,
     ):
-        super(AxisConfig, self).__init__(
+        super().__init__(
             aria=aria,
             bandPosition=bandPosition,
             description=description,
@@ -4991,7 +2350,7 @@ class AxisOrient(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/AxisOrient"}
 
     def __init__(self, *args):
-        super(AxisOrient, self).__init__(*args)
+        super().__init__(*args)
 
 
 class AxisResolveMap(VegaLiteSchema):
@@ -5010,15 +2369,11 @@ class AxisResolveMap(VegaLiteSchema):
 
     def __init__(
         self,
-        x: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        y: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
+        x: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        y: Optional[SchemaBase | ResolveMode_T] = Undefined,
         **kwds,
     ):
-        super(AxisResolveMap, self).__init__(x=x, y=y, **kwds)
+        super().__init__(x=x, y=y, **kwds)
 
 
 class BBox(VegaLiteSchema):
@@ -5029,7 +2384,7 @@ class BBox(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/BBox"}
 
     def __init__(self, *args, **kwds):
-        super(BBox, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class BarConfig(AnyMarkConfig):
@@ -5416,780 +2771,103 @@ class BarConfig(AnyMarkConfig):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(BarConfig, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -6353,435 +3031,40 @@ class BaseTitleNoValueRefs(VegaLiteSchema):
 
     def __init__(
         self,
-        align: Union[
-            "SchemaBase", Literal["left", "center", "right"], UndefinedType
-        ] = Undefined,
-        anchor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        baseline: Union[
-            str, "SchemaBase", Literal["top", "middle", "bottom"], UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        frame: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["bounds", "group"],
-            UndefinedType,
-        ] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["none", "left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        subtitleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        subtitleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        subtitleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        zindex: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[Align_T | SchemaBase] = Undefined,
+        anchor: Optional[dict | Parameter | SchemaBase | TitleAnchor_T] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[str | Baseline_T | SchemaBase] = Undefined,
+        color: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        frame: Optional[str | dict | Parameter | SchemaBase | TitleFrame_T] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | TitleOrient_T] = Undefined,
+        subtitleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        subtitleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        subtitleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        subtitleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        subtitleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        subtitleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        subtitlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        zindex: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(BaseTitleNoValueRefs, self).__init__(
+        super().__init__(
             align=align,
             anchor=anchor,
             angle=angle,
@@ -6817,7 +3100,7 @@ class BinExtent(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/BinExtent"}
 
     def __init__(self, *args, **kwds):
-        super(BinExtent, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class BinParams(VegaLiteSchema):
@@ -6872,21 +3155,19 @@ class BinParams(VegaLiteSchema):
 
     def __init__(
         self,
-        anchor: Union[float, UndefinedType] = Undefined,
-        base: Union[float, UndefinedType] = Undefined,
-        binned: Union[bool, UndefinedType] = Undefined,
-        divide: Union[Sequence[float], UndefinedType] = Undefined,
-        extent: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        minstep: Union[float, UndefinedType] = Undefined,
-        nice: Union[bool, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        steps: Union[Sequence[float], UndefinedType] = Undefined,
+        anchor: Optional[float] = Undefined,
+        base: Optional[float] = Undefined,
+        binned: Optional[bool] = Undefined,
+        divide: Optional[Sequence[float]] = Undefined,
+        extent: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        minstep: Optional[float] = Undefined,
+        nice: Optional[bool] = Undefined,
+        step: Optional[float] = Undefined,
+        steps: Optional[Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(BinParams, self).__init__(
+        super().__init__(
             anchor=anchor,
             base=base,
             binned=binned,
@@ -6907,7 +3188,7 @@ class Binding(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Binding"}
 
     def __init__(self, *args, **kwds):
-        super(Binding, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class BindCheckbox(Binding):
@@ -6934,13 +3215,13 @@ class BindCheckbox(Binding):
 
     def __init__(
         self,
-        input: Union[str, UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        element: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        input: Optional[str] = Undefined,
+        debounce: Optional[float] = Undefined,
+        element: Optional[str | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(BindCheckbox, self).__init__(
+        super().__init__(
             input=input, debounce=debounce, element=element, name=name, **kwds
         )
 
@@ -6970,14 +3251,12 @@ class BindDirect(Binding):
 
     def __init__(
         self,
-        element: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        event: Union[str, UndefinedType] = Undefined,
+        element: Optional[str | dict | SchemaBase] = Undefined,
+        debounce: Optional[float] = Undefined,
+        event: Optional[str] = Undefined,
         **kwds,
     ):
-        super(BindDirect, self).__init__(
-            element=element, debounce=debounce, event=event, **kwds
-        )
+        super().__init__(element=element, debounce=debounce, event=event, **kwds)
 
 
 class BindInput(Binding):
@@ -7012,15 +3291,15 @@ class BindInput(Binding):
 
     def __init__(
         self,
-        autocomplete: Union[str, UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        element: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        input: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        placeholder: Union[str, UndefinedType] = Undefined,
+        autocomplete: Optional[str] = Undefined,
+        debounce: Optional[float] = Undefined,
+        element: Optional[str | SchemaBase] = Undefined,
+        input: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        placeholder: Optional[str] = Undefined,
         **kwds,
     ):
-        super(BindInput, self).__init__(
+        super().__init__(
             autocomplete=autocomplete,
             debounce=debounce,
             element=element,
@@ -7060,15 +3339,15 @@ class BindRadioSelect(Binding):
 
     def __init__(
         self,
-        input: Union[Literal["radio", "select"], UndefinedType] = Undefined,
-        options: Union[Sequence[Any], UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        element: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        labels: Union[Sequence[str], UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        input: Optional[Literal["radio", "select"]] = Undefined,
+        options: Optional[Sequence[Any]] = Undefined,
+        debounce: Optional[float] = Undefined,
+        element: Optional[str | SchemaBase] = Undefined,
+        labels: Optional[Sequence[str]] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(BindRadioSelect, self).__init__(
+        super().__init__(
             input=input,
             options=options,
             debounce=debounce,
@@ -7112,16 +3391,16 @@ class BindRange(Binding):
 
     def __init__(
         self,
-        input: Union[str, UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        element: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        max: Union[float, UndefinedType] = Undefined,
-        min: Union[float, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
+        input: Optional[str] = Undefined,
+        debounce: Optional[float] = Undefined,
+        element: Optional[str | SchemaBase] = Undefined,
+        max: Optional[float] = Undefined,
+        min: Optional[float] = Undefined,
+        name: Optional[str] = Undefined,
+        step: Optional[float] = Undefined,
         **kwds,
     ):
-        super(BindRange, self).__init__(
+        super().__init__(
             input=input,
             debounce=debounce,
             element=element,
@@ -7139,7 +3418,7 @@ class BinnedTimeUnit(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/BinnedTimeUnit"}
 
     def __init__(self, *args, **kwds):
-        super(BinnedTimeUnit, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Blend(VegaLiteSchema):
@@ -7148,7 +3427,7 @@ class Blend(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Blend"}
 
     def __init__(self, *args):
-        super(Blend, self).__init__(*args)
+        super().__init__(*args)
 
 
 class BoxPlotConfig(VegaLiteSchema):
@@ -7187,16 +3466,16 @@ class BoxPlotConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        box: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        extent: Union[str, float, UndefinedType] = Undefined,
-        median: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        outliers: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        rule: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        size: Union[float, UndefinedType] = Undefined,
-        ticks: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
+        box: Optional[bool | dict | SchemaBase] = Undefined,
+        extent: Optional[str | float] = Undefined,
+        median: Optional[bool | dict | SchemaBase] = Undefined,
+        outliers: Optional[bool | dict | SchemaBase] = Undefined,
+        rule: Optional[bool | dict | SchemaBase] = Undefined,
+        size: Optional[float] = Undefined,
+        ticks: Optional[bool | dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(BoxPlotConfig, self).__init__(
+        super().__init__(
             box=box,
             extent=extent,
             median=median,
@@ -7244,366 +3523,17 @@ class BrushConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        cursor: Union[
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fill: Union[
-            str,
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[float, UndefinedType] = Undefined,
-        stroke: Union[
-            str,
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[Sequence[float], UndefinedType] = Undefined,
-        strokeDashOffset: Union[float, UndefinedType] = Undefined,
-        strokeOpacity: Union[float, UndefinedType] = Undefined,
-        strokeWidth: Union[float, UndefinedType] = Undefined,
+        cursor: Optional[Cursor_T | SchemaBase] = Undefined,
+        fill: Optional[str | ColorName_T | SchemaBase] = Undefined,
+        fillOpacity: Optional[float] = Undefined,
+        stroke: Optional[str | ColorName_T | SchemaBase] = Undefined,
+        strokeDash: Optional[Sequence[float]] = Undefined,
+        strokeDashOffset: Optional[float] = Undefined,
+        strokeOpacity: Optional[float] = Undefined,
+        strokeWidth: Optional[float] = Undefined,
         **kwds,
     ):
-        super(BrushConfig, self).__init__(
+        super().__init__(
             cursor=cursor,
             fill=fill,
             fillOpacity=fillOpacity,
@@ -7622,7 +3552,7 @@ class Color(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Color"}
 
     def __init__(self, *args, **kwds):
-        super(Color, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ColorDef(VegaLiteSchema):
@@ -7631,7 +3561,7 @@ class ColorDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ColorDef"}
 
     def __init__(self, *args, **kwds):
-        super(ColorDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ColorName(Color):
@@ -7640,7 +3570,7 @@ class ColorName(Color):
     _schema = {"$ref": "#/definitions/ColorName"}
 
     def __init__(self, *args):
-        super(ColorName, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ColorScheme(VegaLiteSchema):
@@ -7649,7 +3579,7 @@ class ColorScheme(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ColorScheme"}
 
     def __init__(self, *args, **kwds):
-        super(ColorScheme, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Categorical(ColorScheme):
@@ -7658,7 +3588,7 @@ class Categorical(ColorScheme):
     _schema = {"$ref": "#/definitions/Categorical"}
 
     def __init__(self, *args):
-        super(Categorical, self).__init__(*args)
+        super().__init__(*args)
 
 
 class CompositeMark(AnyMark):
@@ -7667,7 +3597,7 @@ class CompositeMark(AnyMark):
     _schema = {"$ref": "#/definitions/CompositeMark"}
 
     def __init__(self, *args, **kwds):
-        super(CompositeMark, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class BoxPlot(CompositeMark):
@@ -7676,7 +3606,7 @@ class BoxPlot(CompositeMark):
     _schema = {"$ref": "#/definitions/BoxPlot"}
 
     def __init__(self, *args):
-        super(BoxPlot, self).__init__(*args)
+        super().__init__(*args)
 
 
 class CompositeMarkDef(AnyMark):
@@ -7685,7 +3615,7 @@ class CompositeMarkDef(AnyMark):
     _schema = {"$ref": "#/definitions/CompositeMarkDef"}
 
     def __init__(self, *args, **kwds):
-        super(CompositeMarkDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class BoxPlotDef(CompositeMarkDef):
@@ -7702,7 +3632,7 @@ class BoxPlotDef(CompositeMarkDef):
     box : bool, dict, :class:`BarConfig`, :class:`AreaConfig`, :class:`LineConfig`, :class:`MarkConfig`, :class:`RectConfig`, :class:`TickConfig`, :class:`AnyMarkConfig`
 
     clip : bool
-        Whether a composite mark be clipped to the enclosing group’s width and height.
+        Whether a composite mark be clipped to the enclosing group's width and height.
     color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']
         Default color.
 
@@ -7761,180 +3691,22 @@ class BoxPlotDef(CompositeMarkDef):
 
     def __init__(
         self,
-        type: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        box: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        clip: Union[bool, UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        extent: Union[str, float, UndefinedType] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        median: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        opacity: Union[float, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outliers: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        rule: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        size: Union[float, UndefinedType] = Undefined,
-        ticks: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
+        type: Optional[str | SchemaBase] = Undefined,
+        box: Optional[bool | dict | SchemaBase] = Undefined,
+        clip: Optional[bool] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        extent: Optional[str | float] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        median: Optional[bool | dict | SchemaBase] = Undefined,
+        opacity: Optional[float] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outliers: Optional[bool | dict | SchemaBase] = Undefined,
+        rule: Optional[bool | dict | SchemaBase] = Undefined,
+        size: Optional[float] = Undefined,
+        ticks: Optional[bool | dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(BoxPlotDef, self).__init__(
+        super().__init__(
             type=type,
             box=box,
             clip=clip,
@@ -7986,13 +3758,11 @@ class CompositionConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        columns: Union[float, UndefinedType] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
+        columns: Optional[float] = Undefined,
+        spacing: Optional[float] = Undefined,
         **kwds,
     ):
-        super(CompositionConfig, self).__init__(
-            columns=columns, spacing=spacing, **kwds
-        )
+        super().__init__(columns=columns, spacing=spacing, **kwds)
 
 
 class ConditionalAxisColor(VegaLiteSchema):
@@ -8001,7 +3771,7 @@ class ConditionalAxisColor(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisColor"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisColor, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisLabelAlign(VegaLiteSchema):
@@ -8010,7 +3780,7 @@ class ConditionalAxisLabelAlign(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisLabelAlign"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisLabelAlign, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisLabelBaseline(VegaLiteSchema):
@@ -8019,7 +3789,7 @@ class ConditionalAxisLabelBaseline(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisLabelBaseline"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisLabelBaseline, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisLabelFontStyle(VegaLiteSchema):
@@ -8028,7 +3798,7 @@ class ConditionalAxisLabelFontStyle(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisLabelFontStyle"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisLabelFontStyle, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisLabelFontWeight(VegaLiteSchema):
@@ -8037,7 +3807,7 @@ class ConditionalAxisLabelFontWeight(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisLabelFontWeight"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisLabelFontWeight, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisNumber(VegaLiteSchema):
@@ -8046,7 +3816,7 @@ class ConditionalAxisNumber(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisNumber"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisNumber, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisNumberArray(VegaLiteSchema):
@@ -8055,7 +3825,7 @@ class ConditionalAxisNumberArray(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisNumberArray"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisNumberArray, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertyAlignnull(VegaLiteSchema):
@@ -8064,7 +3834,7 @@ class ConditionalAxisPropertyAlignnull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(Align|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertyAlignnull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertyColornull(VegaLiteSchema):
@@ -8073,7 +3843,7 @@ class ConditionalAxisPropertyColornull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(Color|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertyColornull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertyFontStylenull(VegaLiteSchema):
@@ -8082,7 +3852,7 @@ class ConditionalAxisPropertyFontStylenull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(FontStyle|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertyFontStylenull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertyFontWeightnull(VegaLiteSchema):
@@ -8091,7 +3861,7 @@ class ConditionalAxisPropertyFontWeightnull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(FontWeight|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertyFontWeightnull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertyTextBaselinenull(VegaLiteSchema):
@@ -8100,7 +3870,7 @@ class ConditionalAxisPropertyTextBaselinenull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(TextBaseline|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertyTextBaselinenull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertynumberArraynull(VegaLiteSchema):
@@ -8109,7 +3879,7 @@ class ConditionalAxisPropertynumberArraynull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(number[]|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertynumberArraynull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertynumbernull(VegaLiteSchema):
@@ -8118,7 +3888,7 @@ class ConditionalAxisPropertynumbernull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(number|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertynumbernull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisPropertystringnull(VegaLiteSchema):
@@ -8127,7 +3897,7 @@ class ConditionalAxisPropertystringnull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisProperty<(string|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisPropertystringnull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalAxisString(VegaLiteSchema):
@@ -8136,7 +3906,7 @@ class ConditionalAxisString(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalAxisString"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalAxisString, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalMarkPropFieldOrDatumDef(VegaLiteSchema):
@@ -8145,7 +3915,7 @@ class ConditionalMarkPropFieldOrDatumDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalMarkPropFieldOrDatumDef"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalMarkPropFieldOrDatumDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalMarkPropFieldOrDatumDefTypeForShape(VegaLiteSchema):
@@ -8154,9 +3924,7 @@ class ConditionalMarkPropFieldOrDatumDefTypeForShape(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalMarkPropFieldOrDatumDef<TypeForShape>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalMarkPropFieldOrDatumDefTypeForShape, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterMarkPropFieldOrDatumDef(ConditionalMarkPropFieldOrDatumDef):
@@ -8165,7 +3933,7 @@ class ConditionalParameterMarkPropFieldOrDatumDef(ConditionalMarkPropFieldOrDatu
     _schema = {"$ref": "#/definitions/ConditionalParameter<MarkPropFieldOrDatumDef>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalParameterMarkPropFieldOrDatumDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterMarkPropFieldOrDatumDefTypeForShape(
@@ -8178,9 +3946,7 @@ class ConditionalParameterMarkPropFieldOrDatumDefTypeForShape(
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalParameterMarkPropFieldOrDatumDefTypeForShape, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateMarkPropFieldOrDatumDef(ConditionalMarkPropFieldOrDatumDef):
@@ -8189,7 +3955,7 @@ class ConditionalPredicateMarkPropFieldOrDatumDef(ConditionalMarkPropFieldOrDatu
     _schema = {"$ref": "#/definitions/ConditionalPredicate<MarkPropFieldOrDatumDef>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateMarkPropFieldOrDatumDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape(
@@ -8202,9 +3968,7 @@ class ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape(
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateMarkPropFieldOrDatumDefTypeForShape, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefAlignnullExprRef(VegaLiteSchema):
@@ -8215,9 +3979,7 @@ class ConditionalPredicateValueDefAlignnullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefAlignnullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefColornullExprRef(VegaLiteSchema):
@@ -8228,9 +3990,7 @@ class ConditionalPredicateValueDefColornullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefColornullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefFontStylenullExprRef(VegaLiteSchema):
@@ -8241,9 +4001,7 @@ class ConditionalPredicateValueDefFontStylenullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefFontStylenullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefFontWeightnullExprRef(VegaLiteSchema):
@@ -8254,9 +4012,7 @@ class ConditionalPredicateValueDefFontWeightnullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefFontWeightnullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefTextBaselinenullExprRef(VegaLiteSchema):
@@ -8267,9 +4023,7 @@ class ConditionalPredicateValueDefTextBaselinenullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefTextBaselinenullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefnumberArraynullExprRef(VegaLiteSchema):
@@ -8280,9 +4034,7 @@ class ConditionalPredicateValueDefnumberArraynullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefnumberArraynullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalPredicateValueDefnumbernullExprRef(VegaLiteSchema):
@@ -8293,9 +4045,7 @@ class ConditionalPredicateValueDefnumbernullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalPredicateValueDefnumbernullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalStringFieldDef(VegaLiteSchema):
@@ -8304,7 +4054,7 @@ class ConditionalStringFieldDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalStringFieldDef"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalStringFieldDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterStringFieldDef(ConditionalStringFieldDef):
@@ -8504,73 +4254,22 @@ class ConditionalParameterStringFieldDef(ConditionalStringFieldDef):
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        param: Optional[str | SchemaBase] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -8585,8 +4284,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -8601,80 +4300,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterStringFieldDef, self).__init__(
+        super().__init__(
             param=param,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -8884,72 +4516,21 @@ class ConditionalPredicateStringFieldDef(ConditionalStringFieldDef):
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -8964,8 +4545,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -8980,80 +4561,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateStringFieldDef, self).__init__(
+        super().__init__(
             test=test,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -9076,9 +4590,7 @@ class ConditionalValueDefGradientstringnullExprRef(VegaLiteSchema):
     }
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefGradientstringnullExprRef, self).__init__(
-            *args, **kwds
-        )
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefGradientstringnullExprRef(
@@ -9106,16 +4618,12 @@ class ConditionalParameterValueDefGradientstringnullExprRef(
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefGradientstringnullExprRef, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefGradientstringnullExprRef(
@@ -9140,15 +4648,11 @@ class ConditionalPredicateValueDefGradientstringnullExprRef(
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefGradientstringnullExprRef, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class ConditionalValueDefTextExprRef(VegaLiteSchema):
@@ -9157,7 +4661,7 @@ class ConditionalValueDefTextExprRef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalValueDef<(Text|ExprRef)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefTextExprRef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefTextExprRef(ConditionalValueDefTextExprRef):
@@ -9181,16 +4685,14 @@ class ConditionalParameterValueDefTextExprRef(ConditionalValueDefTextExprRef):
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefTextExprRef, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefTextExprRef(ConditionalValueDefTextExprRef):
@@ -9211,15 +4713,13 @@ class ConditionalPredicateValueDefTextExprRef(ConditionalValueDefTextExprRef):
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefTextExprRef, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class ConditionalValueDefnumber(VegaLiteSchema):
@@ -9228,7 +4728,7 @@ class ConditionalValueDefnumber(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalValueDef<number>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefnumber, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefnumber(ConditionalValueDefnumber):
@@ -9252,14 +4752,12 @@ class ConditionalParameterValueDefnumber(ConditionalValueDefnumber):
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[float, UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[float] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefnumber, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefnumber(ConditionalValueDefnumber):
@@ -9280,13 +4778,11 @@ class ConditionalPredicateValueDefnumber(ConditionalValueDefnumber):
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[float, UndefinedType] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[float] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefnumber, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class ConditionalValueDefnumberArrayExprRef(VegaLiteSchema):
@@ -9295,7 +4791,7 @@ class ConditionalValueDefnumberArrayExprRef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalValueDef<(number[]|ExprRef)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefnumberArrayExprRef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefnumberArrayExprRef(
@@ -9323,16 +4819,12 @@ class ConditionalParameterValueDefnumberArrayExprRef(
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefnumberArrayExprRef, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefnumberArrayExprRef(
@@ -9357,15 +4849,11 @@ class ConditionalPredicateValueDefnumberArrayExprRef(
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefnumberArrayExprRef, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class ConditionalValueDefnumberExprRef(VegaLiteSchema):
@@ -9374,7 +4862,7 @@ class ConditionalValueDefnumberExprRef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalValueDef<(number|ExprRef)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefnumberExprRef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefnumberExprRef(ConditionalValueDefnumberExprRef):
@@ -9398,16 +4886,12 @@ class ConditionalParameterValueDefnumberExprRef(ConditionalValueDefnumberExprRef
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefnumberExprRef, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefnumberExprRef(ConditionalValueDefnumberExprRef):
@@ -9428,15 +4912,11 @@ class ConditionalPredicateValueDefnumberExprRef(ConditionalValueDefnumberExprRef
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefnumberExprRef, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class ConditionalValueDefstringExprRef(VegaLiteSchema):
@@ -9445,7 +4925,7 @@ class ConditionalValueDefstringExprRef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalValueDef<(string|ExprRef)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefstringExprRef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefstringExprRef(ConditionalValueDefstringExprRef):
@@ -9469,14 +4949,12 @@ class ConditionalParameterValueDefstringExprRef(ConditionalValueDefstringExprRef
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefstringExprRef, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefstringExprRef(ConditionalValueDefstringExprRef):
@@ -9497,13 +4975,11 @@ class ConditionalPredicateValueDefstringExprRef(ConditionalValueDefstringExprRef
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefstringExprRef, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class ConditionalValueDefstringnullExprRef(VegaLiteSchema):
@@ -9512,7 +4988,7 @@ class ConditionalValueDefstringnullExprRef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ConditionalValueDef<(string|null|ExprRef)>"}
 
     def __init__(self, *args, **kwds):
-        super(ConditionalValueDefstringnullExprRef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConditionalParameterValueDefstringnullExprRef(
@@ -9540,16 +5016,12 @@ class ConditionalParameterValueDefstringnullExprRef(
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ConditionalParameterValueDefstringnullExprRef, self).__init__(
-            param=param, value=value, empty=empty, **kwds
-        )
+        super().__init__(param=param, value=value, empty=empty, **kwds)
 
 
 class ConditionalPredicateValueDefstringnullExprRef(
@@ -9574,15 +5046,11 @@ class ConditionalPredicateValueDefstringnullExprRef(
 
     def __init__(
         self,
-        test: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        test: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ConditionalPredicateValueDefstringnullExprRef, self).__init__(
-            test=test, value=value, **kwds
-        )
+        super().__init__(test=test, value=value, **kwds)
 
 
 class Config(VegaLiteSchema):
@@ -9865,248 +5333,83 @@ class Config(VegaLiteSchema):
 
     def __init__(
         self,
-        arc: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        area: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        aria: Union[bool, UndefinedType] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        axis: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisBand: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisBottom: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisDiscrete: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisLeft: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisPoint: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisQuantitative: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisRight: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisTemporal: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisTop: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisX: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisXBand: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisXDiscrete: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisXPoint: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisXQuantitative: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisXTemporal: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisY: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisYBand: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisYDiscrete: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisYPoint: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisYQuantitative: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        axisYTemporal: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bar: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        boxplot: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        circle: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        concat: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        countTitle: Union[str, UndefinedType] = Undefined,
-        customFormatTypes: Union[bool, UndefinedType] = Undefined,
-        errorband: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        errorbar: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        facet: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        fieldTitle: Union[
-            Literal["verbal", "functional", "plain"], UndefinedType
-        ] = Undefined,
-        font: Union[str, UndefinedType] = Undefined,
-        geoshape: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        header: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        headerColumn: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        headerFacet: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        headerRow: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        image: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        legend: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        line: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        locale: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        mark: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        normalizedNumberFormat: Union[str, UndefinedType] = Undefined,
-        normalizedNumberFormatType: Union[str, UndefinedType] = Undefined,
-        numberFormat: Union[str, UndefinedType] = Undefined,
-        numberFormatType: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        point: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        range: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        rect: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        rule: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        selection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        square: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        style: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        text: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        tick: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        timeFormat: Union[str, UndefinedType] = Undefined,
-        timeFormatType: Union[str, UndefinedType] = Undefined,
-        title: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        tooltipFormat: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        trail: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        view: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        arc: Optional[dict | SchemaBase] = Undefined,
+        area: Optional[dict | SchemaBase] = Undefined,
+        aria: Optional[bool] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        axis: Optional[dict | SchemaBase] = Undefined,
+        axisBand: Optional[dict | SchemaBase] = Undefined,
+        axisBottom: Optional[dict | SchemaBase] = Undefined,
+        axisDiscrete: Optional[dict | SchemaBase] = Undefined,
+        axisLeft: Optional[dict | SchemaBase] = Undefined,
+        axisPoint: Optional[dict | SchemaBase] = Undefined,
+        axisQuantitative: Optional[dict | SchemaBase] = Undefined,
+        axisRight: Optional[dict | SchemaBase] = Undefined,
+        axisTemporal: Optional[dict | SchemaBase] = Undefined,
+        axisTop: Optional[dict | SchemaBase] = Undefined,
+        axisX: Optional[dict | SchemaBase] = Undefined,
+        axisXBand: Optional[dict | SchemaBase] = Undefined,
+        axisXDiscrete: Optional[dict | SchemaBase] = Undefined,
+        axisXPoint: Optional[dict | SchemaBase] = Undefined,
+        axisXQuantitative: Optional[dict | SchemaBase] = Undefined,
+        axisXTemporal: Optional[dict | SchemaBase] = Undefined,
+        axisY: Optional[dict | SchemaBase] = Undefined,
+        axisYBand: Optional[dict | SchemaBase] = Undefined,
+        axisYDiscrete: Optional[dict | SchemaBase] = Undefined,
+        axisYPoint: Optional[dict | SchemaBase] = Undefined,
+        axisYQuantitative: Optional[dict | SchemaBase] = Undefined,
+        axisYTemporal: Optional[dict | SchemaBase] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        bar: Optional[dict | SchemaBase] = Undefined,
+        boxplot: Optional[dict | SchemaBase] = Undefined,
+        circle: Optional[dict | SchemaBase] = Undefined,
+        concat: Optional[dict | SchemaBase] = Undefined,
+        countTitle: Optional[str] = Undefined,
+        customFormatTypes: Optional[bool] = Undefined,
+        errorband: Optional[dict | SchemaBase] = Undefined,
+        errorbar: Optional[dict | SchemaBase] = Undefined,
+        facet: Optional[dict | SchemaBase] = Undefined,
+        fieldTitle: Optional[Literal["verbal", "functional", "plain"]] = Undefined,
+        font: Optional[str] = Undefined,
+        geoshape: Optional[dict | SchemaBase] = Undefined,
+        header: Optional[dict | SchemaBase] = Undefined,
+        headerColumn: Optional[dict | SchemaBase] = Undefined,
+        headerFacet: Optional[dict | SchemaBase] = Undefined,
+        headerRow: Optional[dict | SchemaBase] = Undefined,
+        image: Optional[dict | SchemaBase] = Undefined,
+        legend: Optional[dict | SchemaBase] = Undefined,
+        line: Optional[dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        locale: Optional[dict | SchemaBase] = Undefined,
+        mark: Optional[dict | SchemaBase] = Undefined,
+        normalizedNumberFormat: Optional[str] = Undefined,
+        normalizedNumberFormatType: Optional[str] = Undefined,
+        numberFormat: Optional[str] = Undefined,
+        numberFormatType: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        point: Optional[dict | SchemaBase] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        range: Optional[dict | SchemaBase] = Undefined,
+        rect: Optional[dict | SchemaBase] = Undefined,
+        rule: Optional[dict | SchemaBase] = Undefined,
+        scale: Optional[dict | SchemaBase] = Undefined,
+        selection: Optional[dict | SchemaBase] = Undefined,
+        square: Optional[dict | SchemaBase] = Undefined,
+        style: Optional[dict | SchemaBase] = Undefined,
+        text: Optional[dict | SchemaBase] = Undefined,
+        tick: Optional[dict | SchemaBase] = Undefined,
+        timeFormat: Optional[str] = Undefined,
+        timeFormatType: Optional[str] = Undefined,
+        title: Optional[dict | SchemaBase] = Undefined,
+        tooltipFormat: Optional[dict | SchemaBase] = Undefined,
+        trail: Optional[dict | SchemaBase] = Undefined,
+        view: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Config, self).__init__(
+        super().__init__(
             arc=arc,
             area=area,
             aria=aria,
@@ -10189,7 +5492,7 @@ class Cursor(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Cursor"}
 
     def __init__(self, *args):
-        super(Cursor, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Cyclical(ColorScheme):
@@ -10198,7 +5501,7 @@ class Cyclical(ColorScheme):
     _schema = {"$ref": "#/definitions/Cyclical"}
 
     def __init__(self, *args):
-        super(Cyclical, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Data(VegaLiteSchema):
@@ -10207,7 +5510,7 @@ class Data(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Data"}
 
     def __init__(self, *args, **kwds):
-        super(Data, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class DataFormat(VegaLiteSchema):
@@ -10216,7 +5519,7 @@ class DataFormat(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/DataFormat"}
 
     def __init__(self, *args, **kwds):
-        super(DataFormat, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class CsvDataFormat(DataFormat):
@@ -10252,11 +5555,11 @@ class CsvDataFormat(DataFormat):
 
     def __init__(
         self,
-        parse: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        type: Union[Literal["csv", "tsv"], UndefinedType] = Undefined,
+        parse: Optional[dict | None | SchemaBase] = Undefined,
+        type: Optional[Literal["csv", "tsv"]] = Undefined,
         **kwds,
     ):
-        super(CsvDataFormat, self).__init__(parse=parse, type=type, **kwds)
+        super().__init__(parse=parse, type=type, **kwds)
 
 
 class DataSource(Data):
@@ -10265,7 +5568,7 @@ class DataSource(Data):
     _schema = {"$ref": "#/definitions/DataSource"}
 
     def __init__(self, *args, **kwds):
-        super(DataSource, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Datasets(VegaLiteSchema):
@@ -10274,7 +5577,7 @@ class Datasets(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Datasets"}
 
     def __init__(self, **kwds):
-        super(Datasets, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class Day(VegaLiteSchema):
@@ -10283,7 +5586,7 @@ class Day(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Day"}
 
     def __init__(self, *args):
-        super(Day, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Dict(VegaLiteSchema):
@@ -10292,7 +5595,7 @@ class Dict(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Dict"}
 
     def __init__(self, **kwds):
-        super(Dict, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class DictInlineDataset(VegaLiteSchema):
@@ -10301,7 +5604,7 @@ class DictInlineDataset(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Dict<InlineDataset>"}
 
     def __init__(self, **kwds):
-        super(DictInlineDataset, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class DictSelectionInit(VegaLiteSchema):
@@ -10310,7 +5613,7 @@ class DictSelectionInit(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Dict<SelectionInit>"}
 
     def __init__(self, **kwds):
-        super(DictSelectionInit, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class DictSelectionInitInterval(VegaLiteSchema):
@@ -10319,7 +5622,7 @@ class DictSelectionInitInterval(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Dict<SelectionInitInterval>"}
 
     def __init__(self, **kwds):
-        super(DictSelectionInitInterval, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class Diverging(ColorScheme):
@@ -10328,7 +5631,7 @@ class Diverging(ColorScheme):
     _schema = {"$ref": "#/definitions/Diverging"}
 
     def __init__(self, *args):
-        super(Diverging, self).__init__(*args)
+        super().__init__(*args)
 
 
 class DomainUnionWith(VegaLiteSchema):
@@ -10346,12 +5649,12 @@ class DomainUnionWith(VegaLiteSchema):
 
     def __init__(
         self,
-        unionWith: Union[
-            Sequence[Union[str, bool, dict, float, "SchemaBase"]], UndefinedType
+        unionWith: Optional[
+            Sequence[str | bool | dict | float | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(DomainUnionWith, self).__init__(unionWith=unionWith, **kwds)
+        super().__init__(unionWith=unionWith, **kwds)
 
 
 class DsvDataFormat(DataFormat):
@@ -10391,14 +5694,12 @@ class DsvDataFormat(DataFormat):
 
     def __init__(
         self,
-        delimiter: Union[str, UndefinedType] = Undefined,
-        parse: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
+        delimiter: Optional[str] = Undefined,
+        parse: Optional[dict | None | SchemaBase] = Undefined,
+        type: Optional[str] = Undefined,
         **kwds,
     ):
-        super(DsvDataFormat, self).__init__(
-            delimiter=delimiter, parse=parse, type=type, **kwds
-        )
+        super().__init__(delimiter=delimiter, parse=parse, type=type, **kwds)
 
 
 class Element(VegaLiteSchema):
@@ -10407,7 +5708,7 @@ class Element(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Element"}
 
     def __init__(self, *args):
-        super(Element, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Encoding(VegaLiteSchema):
@@ -10419,7 +5720,7 @@ class Encoding(VegaLiteSchema):
     angle : dict, :class:`NumericMarkPropDef`, :class:`FieldOrDatumDefWithConditionDatumDefnumber`, :class:`FieldOrDatumDefWithConditionMarkPropFieldDefnumber`, :class:`ValueDefWithConditionMarkPropFieldOrDatumDefnumber`
         Rotation angle of point and text marks.
     color : dict, :class:`ColorDef`, :class:`FieldOrDatumDefWithConditionDatumDefGradientstringnull`, :class:`FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull`, :class:`ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull`
-        Color of the marks – either fill or stroke color based on  the ``filled`` property
+        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"``.
@@ -10456,7 +5757,7 @@ class Encoding(VegaLiteSchema):
     href : dict, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`
         A URL to load upon mouse click.
     key : dict, :class:`FieldDefWithoutScale`
-        A data field to use as a unique key for data binding. When a visualization’s data is
+        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.
@@ -10519,10 +5820,10 @@ class Encoding(VegaLiteSchema):
         Size of the mark.
 
 
-        * For ``"point"``, ``"square"`` and ``"circle"``, – the symbol size, or pixel area
+        * 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.
+        * 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 : dict, :class:`ColorDef`, :class:`FieldOrDatumDefWithConditionDatumDefGradientstringnull`, :class:`FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull`, :class:`ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull`
@@ -10611,52 +5912,48 @@ class Encoding(VegaLiteSchema):
 
     def __init__(
         self,
-        angle: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        color: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        detail: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        fill: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        fillOpacity: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        href: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        key: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        latitude: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        latitude2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        longitude: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        longitude2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        opacity: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        order: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        radius: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        radius2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        shape: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        stroke: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        strokeDash: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        strokeOpacity: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        strokeWidth: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        text: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        theta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        theta2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        tooltip: Union[
-            dict, None, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        url: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        x: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        x2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        xError: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        xError2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        xOffset: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        y: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        y2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        yError: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        yError2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        yOffset: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        angle: Optional[dict | SchemaBase] = Undefined,
+        color: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[dict | SchemaBase] = Undefined,
+        detail: Optional[dict | SchemaBase | Sequence[dict | SchemaBase]] = Undefined,
+        fill: Optional[dict | SchemaBase] = Undefined,
+        fillOpacity: Optional[dict | SchemaBase] = Undefined,
+        href: Optional[dict | SchemaBase] = Undefined,
+        key: Optional[dict | SchemaBase] = Undefined,
+        latitude: Optional[dict | SchemaBase] = Undefined,
+        latitude2: Optional[dict | SchemaBase] = Undefined,
+        longitude: Optional[dict | SchemaBase] = Undefined,
+        longitude2: Optional[dict | SchemaBase] = Undefined,
+        opacity: Optional[dict | SchemaBase] = Undefined,
+        order: Optional[dict | SchemaBase | Sequence[dict | SchemaBase]] = Undefined,
+        radius: Optional[dict | SchemaBase] = Undefined,
+        radius2: Optional[dict | SchemaBase] = Undefined,
+        shape: Optional[dict | SchemaBase] = Undefined,
+        size: Optional[dict | SchemaBase] = Undefined,
+        stroke: Optional[dict | SchemaBase] = Undefined,
+        strokeDash: Optional[dict | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | SchemaBase] = Undefined,
+        text: Optional[dict | SchemaBase] = Undefined,
+        theta: Optional[dict | SchemaBase] = Undefined,
+        theta2: Optional[dict | SchemaBase] = Undefined,
+        tooltip: Optional[
+            dict | None | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        url: Optional[dict | SchemaBase] = Undefined,
+        x: Optional[dict | SchemaBase] = Undefined,
+        x2: Optional[dict | SchemaBase] = Undefined,
+        xError: Optional[dict | SchemaBase] = Undefined,
+        xError2: Optional[dict | SchemaBase] = Undefined,
+        xOffset: Optional[dict | SchemaBase] = Undefined,
+        y: Optional[dict | SchemaBase] = Undefined,
+        y2: Optional[dict | SchemaBase] = Undefined,
+        yError: Optional[dict | SchemaBase] = Undefined,
+        yError2: Optional[dict | SchemaBase] = Undefined,
+        yOffset: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Encoding, self).__init__(
+        super().__init__(
             angle=angle,
             color=color,
             description=description,
@@ -10704,7 +6001,7 @@ class ErrorBand(CompositeMark):
     _schema = {"$ref": "#/definitions/ErrorBand"}
 
     def __init__(self, *args):
-        super(ErrorBand, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ErrorBandConfig(VegaLiteSchema):
@@ -10760,36 +6057,14 @@ class ErrorBandConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        band: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        borders: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        extent: Union[
-            "SchemaBase", Literal["ci", "iqr", "stderr", "stdev"], UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tension: Union[float, UndefinedType] = Undefined,
+        band: Optional[bool | dict | SchemaBase] = Undefined,
+        borders: Optional[bool | dict | SchemaBase] = Undefined,
+        extent: Optional[SchemaBase | ErrorBarExtent_T] = Undefined,
+        interpolate: Optional[SchemaBase | Interpolate_T] = Undefined,
+        tension: Optional[float] = Undefined,
         **kwds,
     ):
-        super(ErrorBandConfig, self).__init__(
+        super().__init__(
             band=band,
             borders=borders,
             extent=extent,
@@ -10815,7 +6090,7 @@ class ErrorBandDef(CompositeMarkDef):
     borders : bool, dict, :class:`BarConfig`, :class:`AreaConfig`, :class:`LineConfig`, :class:`MarkConfig`, :class:`RectConfig`, :class:`TickConfig`, :class:`AnyMarkConfig`
 
     clip : bool
-        Whether a composite mark be clipped to the enclosing group’s width and height.
+        Whether a composite mark be clipped to the enclosing group's width and height.
     color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']
         Default color.
 
@@ -10877,199 +6152,19 @@ class ErrorBandDef(CompositeMarkDef):
 
     def __init__(
         self,
-        type: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        band: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        borders: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        clip: Union[bool, UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        extent: Union[
-            "SchemaBase", Literal["ci", "iqr", "stderr", "stdev"], UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        opacity: Union[float, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        tension: Union[float, UndefinedType] = Undefined,
+        type: Optional[str | SchemaBase] = Undefined,
+        band: Optional[bool | dict | SchemaBase] = Undefined,
+        borders: Optional[bool | dict | SchemaBase] = Undefined,
+        clip: Optional[bool] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        extent: Optional[SchemaBase | ErrorBarExtent_T] = Undefined,
+        interpolate: Optional[SchemaBase | Interpolate_T] = Undefined,
+        opacity: Optional[float] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        tension: Optional[float] = Undefined,
         **kwds,
     ):
-        super(ErrorBandDef, self).__init__(
+        super().__init__(
             type=type,
             band=band,
             borders=borders,
@@ -11090,7 +6185,7 @@ class ErrorBar(CompositeMark):
     _schema = {"$ref": "#/definitions/ErrorBar"}
 
     def __init__(self, *args):
-        super(ErrorBar, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ErrorBarConfig(VegaLiteSchema):
@@ -11125,16 +6220,14 @@ class ErrorBarConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        extent: Union[
-            "SchemaBase", Literal["ci", "iqr", "stderr", "stdev"], UndefinedType
-        ] = Undefined,
-        rule: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        size: Union[float, UndefinedType] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        ticks: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
+        extent: Optional[SchemaBase | ErrorBarExtent_T] = Undefined,
+        rule: Optional[bool | dict | SchemaBase] = Undefined,
+        size: Optional[float] = Undefined,
+        thickness: Optional[float] = Undefined,
+        ticks: Optional[bool | dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ErrorBarConfig, self).__init__(
+        super().__init__(
             extent=extent,
             rule=rule,
             size=size,
@@ -11156,7 +6249,7 @@ class ErrorBarDef(CompositeMarkDef):
         ``"rule"``, and ``"text"`` ) or a composite mark type ( ``"boxplot"``,
         ``"errorband"``, ``"errorbar"`` ).
     clip : bool
-        Whether a composite mark be clipped to the enclosing group’s width and height.
+        Whether a composite mark be clipped to the enclosing group's width and height.
     color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']
         Default color.
 
@@ -11201,179 +6294,19 @@ class ErrorBarDef(CompositeMarkDef):
 
     def __init__(
         self,
-        type: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        clip: Union[bool, UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        extent: Union[
-            "SchemaBase", Literal["ci", "iqr", "stderr", "stdev"], UndefinedType
-        ] = Undefined,
-        opacity: Union[float, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        rule: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        size: Union[float, UndefinedType] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        ticks: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
+        type: Optional[str | SchemaBase] = Undefined,
+        clip: Optional[bool] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        extent: Optional[SchemaBase | ErrorBarExtent_T] = Undefined,
+        opacity: Optional[float] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        rule: Optional[bool | dict | SchemaBase] = Undefined,
+        size: Optional[float] = Undefined,
+        thickness: Optional[float] = Undefined,
+        ticks: Optional[bool | dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ErrorBarDef, self).__init__(
+        super().__init__(
             type=type,
             clip=clip,
             color=color,
@@ -11394,7 +6327,7 @@ class ErrorBarExtent(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ErrorBarExtent"}
 
     def __init__(self, *args):
-        super(ErrorBarExtent, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Expr(VegaLiteSchema):
@@ -11403,7 +6336,7 @@ class Expr(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Expr"}
 
     def __init__(self, *args):
-        super(Expr, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ExprRef(VegaLiteSchema):
@@ -11418,8 +6351,8 @@ class ExprRef(VegaLiteSchema):
 
     _schema = {"$ref": "#/definitions/ExprRef"}
 
-    def __init__(self, expr: Union[str, UndefinedType] = Undefined, **kwds):
-        super(ExprRef, self).__init__(expr=expr, **kwds)
+    def __init__(self, expr: Optional[str] = Undefined, **kwds):
+        super().__init__(expr=expr, **kwds)
 
 
 class FacetEncodingFieldDef(VegaLiteSchema):
@@ -11674,91 +6607,35 @@ class FacetEncodingFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        header: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        header: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -11773,8 +6650,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -11789,80 +6666,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FacetEncodingFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             align=align,
@@ -12069,81 +6879,29 @@ class FacetFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        header: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        header: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -12158,8 +6916,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -12174,80 +6932,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FacetFieldDef, self).__init__(
+        super().__init__(
             aggregate=aggregate,
             bandPosition=bandPosition,
             bin=bin,
@@ -12277,11 +6968,11 @@ class FacetMapping(VegaLiteSchema):
 
     def __init__(
         self,
-        column: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        row: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        column: Optional[dict | SchemaBase] = Undefined,
+        row: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FacetMapping, self).__init__(column=column, row=row, **kwds)
+        super().__init__(column=column, row=row, **kwds)
 
 
 class FacetedEncoding(VegaLiteSchema):
@@ -12293,7 +6984,7 @@ class FacetedEncoding(VegaLiteSchema):
     angle : dict, :class:`NumericMarkPropDef`, :class:`FieldOrDatumDefWithConditionDatumDefnumber`, :class:`FieldOrDatumDefWithConditionMarkPropFieldDefnumber`, :class:`ValueDefWithConditionMarkPropFieldOrDatumDefnumber`
         Rotation angle of point and text marks.
     color : dict, :class:`ColorDef`, :class:`FieldOrDatumDefWithConditionDatumDefGradientstringnull`, :class:`FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull`, :class:`ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull`
-        Color of the marks – either fill or stroke color based on  the ``filled`` property
+        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"``.
@@ -12336,7 +7027,7 @@ class FacetedEncoding(VegaLiteSchema):
     href : dict, :class:`StringFieldDefWithCondition`, :class:`StringValueDefWithCondition`
         A URL to load upon mouse click.
     key : dict, :class:`FieldDefWithoutScale`
-        A data field to use as a unique key for data binding. When a visualization’s data is
+        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.
@@ -12401,10 +7092,10 @@ class FacetedEncoding(VegaLiteSchema):
         Size of the mark.
 
 
-        * For ``"point"``, ``"square"`` and ``"circle"``, – the symbol size, or pixel area
+        * 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.
+        * 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 : dict, :class:`ColorDef`, :class:`FieldOrDatumDefWithConditionDatumDefGradientstringnull`, :class:`FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull`, :class:`ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull`
@@ -12493,55 +7184,51 @@ class FacetedEncoding(VegaLiteSchema):
 
     def __init__(
         self,
-        angle: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        color: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        column: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        detail: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        facet: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        fill: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        fillOpacity: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        href: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        key: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        latitude: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        latitude2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        longitude: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        longitude2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        opacity: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        order: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        radius: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        radius2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        row: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        shape: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        stroke: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        strokeDash: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        strokeOpacity: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        strokeWidth: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        text: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        theta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        theta2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        tooltip: Union[
-            dict, None, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        url: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        x: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        x2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        xError: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        xError2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        xOffset: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        y: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        y2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        yError: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        yError2: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        yOffset: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        angle: Optional[dict | SchemaBase] = Undefined,
+        color: Optional[dict | SchemaBase] = Undefined,
+        column: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[dict | SchemaBase] = Undefined,
+        detail: Optional[dict | SchemaBase | Sequence[dict | SchemaBase]] = Undefined,
+        facet: Optional[dict | SchemaBase] = Undefined,
+        fill: Optional[dict | SchemaBase] = Undefined,
+        fillOpacity: Optional[dict | SchemaBase] = Undefined,
+        href: Optional[dict | SchemaBase] = Undefined,
+        key: Optional[dict | SchemaBase] = Undefined,
+        latitude: Optional[dict | SchemaBase] = Undefined,
+        latitude2: Optional[dict | SchemaBase] = Undefined,
+        longitude: Optional[dict | SchemaBase] = Undefined,
+        longitude2: Optional[dict | SchemaBase] = Undefined,
+        opacity: Optional[dict | SchemaBase] = Undefined,
+        order: Optional[dict | SchemaBase | Sequence[dict | SchemaBase]] = Undefined,
+        radius: Optional[dict | SchemaBase] = Undefined,
+        radius2: Optional[dict | SchemaBase] = Undefined,
+        row: Optional[dict | SchemaBase] = Undefined,
+        shape: Optional[dict | SchemaBase] = Undefined,
+        size: Optional[dict | SchemaBase] = Undefined,
+        stroke: Optional[dict | SchemaBase] = Undefined,
+        strokeDash: Optional[dict | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | SchemaBase] = Undefined,
+        text: Optional[dict | SchemaBase] = Undefined,
+        theta: Optional[dict | SchemaBase] = Undefined,
+        theta2: Optional[dict | SchemaBase] = Undefined,
+        tooltip: Optional[
+            dict | None | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        url: Optional[dict | SchemaBase] = Undefined,
+        x: Optional[dict | SchemaBase] = Undefined,
+        x2: Optional[dict | SchemaBase] = Undefined,
+        xError: Optional[dict | SchemaBase] = Undefined,
+        xError2: Optional[dict | SchemaBase] = Undefined,
+        xOffset: Optional[dict | SchemaBase] = Undefined,
+        y: Optional[dict | SchemaBase] = Undefined,
+        y2: Optional[dict | SchemaBase] = Undefined,
+        yError: Optional[dict | SchemaBase] = Undefined,
+        yError2: Optional[dict | SchemaBase] = Undefined,
+        yOffset: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FacetedEncoding, self).__init__(
+        super().__init__(
             angle=angle,
             color=color,
             column=column,
@@ -12612,14 +7299,14 @@ class Feature(VegaLiteSchema):
 
     def __init__(
         self,
-        geometry: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        properties: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        id: Union[str, float, UndefinedType] = Undefined,
+        geometry: Optional[dict | SchemaBase] = Undefined,
+        properties: Optional[dict | None | SchemaBase] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
+        id: Optional[str | float] = Undefined,
         **kwds,
     ):
-        super(Feature, self).__init__(
+        super().__init__(
             geometry=geometry,
             properties=properties,
             type=type,
@@ -12649,14 +7336,12 @@ class FeatureCollection(VegaLiteSchema):
 
     def __init__(
         self,
-        features: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        features: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(FeatureCollection, self).__init__(
-            features=features, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(features=features, type=type, bbox=bbox, **kwds)
 
 
 class FeatureGeometryGeoJsonProperties(VegaLiteSchema):
@@ -12685,14 +7370,14 @@ class FeatureGeometryGeoJsonProperties(VegaLiteSchema):
 
     def __init__(
         self,
-        geometry: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        properties: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        id: Union[str, float, UndefinedType] = Undefined,
+        geometry: Optional[dict | SchemaBase] = Undefined,
+        properties: Optional[dict | None | SchemaBase] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
+        id: Optional[str | float] = Undefined,
         **kwds,
     ):
-        super(FeatureGeometryGeoJsonProperties, self).__init__(
+        super().__init__(
             geometry=geometry,
             properties=properties,
             type=type,
@@ -12708,7 +7393,7 @@ class Field(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Field"}
 
     def __init__(self, *args, **kwds):
-        super(Field, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldDefWithoutScale(VegaLiteSchema):
@@ -12872,72 +7557,19 @@ class FieldDefWithoutScale(VegaLiteSchema):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -12952,8 +7584,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -12968,80 +7600,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FieldDefWithoutScale, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -13060,7 +7625,7 @@ class FieldName(Field):
     _schema = {"$ref": "#/definitions/FieldName"}
 
     def __init__(self, *args):
-        super(FieldName, self).__init__(*args)
+        super().__init__(*args)
 
 
 class FieldOrDatumDefWithConditionStringFieldDefstring(VegaLiteSchema):
@@ -13264,74 +7829,23 @@ class FieldOrDatumDefWithConditionStringFieldDefstring(VegaLiteSchema):
 
     def __init__(
         self,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -13346,8 +7860,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -13362,80 +7876,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionStringFieldDefstring, self).__init__(
+        super().__init__(
             aggregate=aggregate,
             bandPosition=bandPosition,
             bin=bin,
@@ -13462,8 +7909,8 @@ class FieldRange(VegaLiteSchema):
 
     _schema = {"$ref": "#/definitions/FieldRange"}
 
-    def __init__(self, field: Union[str, UndefinedType] = Undefined, **kwds):
-        super(FieldRange, self).__init__(field=field, **kwds)
+    def __init__(self, field: Optional[str] = Undefined, **kwds):
+        super().__init__(field=field, **kwds)
 
 
 class Fit(VegaLiteSchema):
@@ -13472,7 +7919,7 @@ class Fit(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Fit"}
 
     def __init__(self, *args, **kwds):
-        super(Fit, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FontStyle(VegaLiteSchema):
@@ -13481,7 +7928,7 @@ class FontStyle(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/FontStyle"}
 
     def __init__(self, *args):
-        super(FontStyle, self).__init__(*args)
+        super().__init__(*args)
 
 
 class FontWeight(VegaLiteSchema):
@@ -13490,7 +7937,7 @@ class FontWeight(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/FontWeight"}
 
     def __init__(self, *args):
-        super(FontWeight, self).__init__(*args)
+        super().__init__(*args)
 
 
 class FormatConfig(VegaLiteSchema):
@@ -13558,15 +8005,15 @@ class FormatConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        normalizedNumberFormat: Union[str, UndefinedType] = Undefined,
-        normalizedNumberFormatType: Union[str, UndefinedType] = Undefined,
-        numberFormat: Union[str, UndefinedType] = Undefined,
-        numberFormatType: Union[str, UndefinedType] = Undefined,
-        timeFormat: Union[str, UndefinedType] = Undefined,
-        timeFormatType: Union[str, UndefinedType] = Undefined,
+        normalizedNumberFormat: Optional[str] = Undefined,
+        normalizedNumberFormatType: Optional[str] = Undefined,
+        numberFormat: Optional[str] = Undefined,
+        numberFormatType: Optional[str] = Undefined,
+        timeFormat: Optional[str] = Undefined,
+        timeFormatType: Optional[str] = Undefined,
         **kwds,
     ):
-        super(FormatConfig, self).__init__(
+        super().__init__(
             normalizedNumberFormat=normalizedNumberFormat,
             normalizedNumberFormatType=normalizedNumberFormatType,
             numberFormat=numberFormat,
@@ -13583,7 +8030,7 @@ class Generator(Data):
     _schema = {"$ref": "#/definitions/Generator"}
 
     def __init__(self, *args, **kwds):
-        super(Generator, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class GenericUnitSpecEncodingAnyMark(VegaLiteSchema):
@@ -13624,41 +8071,18 @@ class GenericUnitSpecEncodingAnyMark(VegaLiteSchema):
 
     def __init__(
         self,
-        mark: Union[
-            str,
-            dict,
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "bar",
-                "image",
-                "line",
-                "point",
-                "rect",
-                "rule",
-                "text",
-                "tick",
-                "trail",
-                "circle",
-                "square",
-                "geoshape",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        mark: Optional[str | dict | Mark_T | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(GenericUnitSpecEncodingAnyMark, self).__init__(
+        super().__init__(
             mark=mark,
             data=data,
             description=description,
@@ -13698,14 +8122,14 @@ class GeoJsonFeature(Fit):
 
     def __init__(
         self,
-        geometry: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        properties: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        id: Union[str, float, UndefinedType] = Undefined,
+        geometry: Optional[dict | SchemaBase] = Undefined,
+        properties: Optional[dict | None | SchemaBase] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
+        id: Optional[str | float] = Undefined,
         **kwds,
     ):
-        super(GeoJsonFeature, self).__init__(
+        super().__init__(
             geometry=geometry,
             properties=properties,
             type=type,
@@ -13735,14 +8159,12 @@ class GeoJsonFeatureCollection(Fit):
 
     def __init__(
         self,
-        features: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        features: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(GeoJsonFeatureCollection, self).__init__(
-            features=features, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(features=features, type=type, bbox=bbox, **kwds)
 
 
 class GeoJsonProperties(VegaLiteSchema):
@@ -13751,7 +8173,7 @@ class GeoJsonProperties(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/GeoJsonProperties"}
 
     def __init__(self, *args, **kwds):
-        super(GeoJsonProperties, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Geometry(VegaLiteSchema):
@@ -13762,7 +8184,7 @@ class Geometry(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Geometry"}
 
     def __init__(self, *args, **kwds):
-        super(Geometry, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class GeometryCollection(Geometry):
@@ -13785,16 +8207,12 @@ class GeometryCollection(Geometry):
 
     def __init__(
         self,
-        geometries: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        geometries: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(GeometryCollection, self).__init__(
-            geometries=geometries, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(geometries=geometries, type=type, bbox=bbox, **kwds)
 
 
 class Gradient(VegaLiteSchema):
@@ -13803,7 +8221,7 @@ class Gradient(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Gradient"}
 
     def __init__(self, *args, **kwds):
-        super(Gradient, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class GradientStop(VegaLiteSchema):
@@ -13822,165 +8240,11 @@ class GradientStop(VegaLiteSchema):
 
     def __init__(
         self,
-        color: Union[
-            str,
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        offset: Union[float, UndefinedType] = Undefined,
+        color: Optional[str | ColorName_T | SchemaBase] = Undefined,
+        offset: Optional[float] = Undefined,
         **kwds,
     ):
-        super(GradientStop, self).__init__(color=color, offset=offset, **kwds)
+        super().__init__(color=color, offset=offset, **kwds)
 
 
 class GraticuleGenerator(Generator):
@@ -13999,11 +8263,11 @@ class GraticuleGenerator(Generator):
 
     def __init__(
         self,
-        graticule: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        graticule: Optional[bool | dict | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(GraticuleGenerator, self).__init__(graticule=graticule, name=name, **kwds)
+        super().__init__(graticule=graticule, name=name, **kwds)
 
 
 class GraticuleParams(VegaLiteSchema):
@@ -14038,22 +8302,22 @@ class GraticuleParams(VegaLiteSchema):
 
     def __init__(
         self,
-        extent: Union[
-            "SchemaBase", Sequence[Union["SchemaBase", Sequence[float]]], UndefinedType
+        extent: Optional[
+            SchemaBase | Sequence[SchemaBase | Sequence[float]]
         ] = Undefined,
-        extentMajor: Union[
-            "SchemaBase", Sequence[Union["SchemaBase", Sequence[float]]], UndefinedType
+        extentMajor: Optional[
+            SchemaBase | Sequence[SchemaBase | Sequence[float]]
         ] = Undefined,
-        extentMinor: Union[
-            "SchemaBase", Sequence[Union["SchemaBase", Sequence[float]]], UndefinedType
+        extentMinor: Optional[
+            SchemaBase | Sequence[SchemaBase | Sequence[float]]
         ] = Undefined,
-        precision: Union[float, UndefinedType] = Undefined,
-        step: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        stepMajor: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        stepMinor: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        precision: Optional[float] = Undefined,
+        step: Optional[SchemaBase | Sequence[float]] = Undefined,
+        stepMajor: Optional[SchemaBase | Sequence[float]] = Undefined,
+        stepMinor: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(GraticuleParams, self).__init__(
+        super().__init__(
             extent=extent,
             extentMajor=extentMajor,
             extentMinor=extentMinor,
@@ -14231,453 +8495,53 @@ class Header(VegaLiteSchema):
 
     def __init__(
         self,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        labelAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAnchor: Union[
-            "SchemaBase", Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        labelAngle: Union[float, UndefinedType] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOrient: Union[
-            "SchemaBase", Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        titleAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            "SchemaBase", Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        titleAngle: Union[float, UndefinedType] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            "SchemaBase", Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        labelAngle: Optional[float] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        orient: Optional[Orient_T | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        titleAngle: Optional[float] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Header, self).__init__(
+        super().__init__(
             format=format,
             formatType=formatType,
             labelAlign=labelAlign,
@@ -14861,453 +8725,53 @@ class HeaderConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        labelAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelAnchor: Union[
-            "SchemaBase", Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        labelAngle: Union[float, UndefinedType] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOrient: Union[
-            "SchemaBase", Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labels: Union[bool, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        title: Union[None, UndefinedType] = Undefined,
-        titleAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            "SchemaBase", Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        titleAngle: Union[float, UndefinedType] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            "SchemaBase", Literal["left", "right", "top", "bottom"], UndefinedType
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        labelAngle: Optional[float] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labels: Optional[bool] = Undefined,
+        orient: Optional[Orient_T | SchemaBase] = Undefined,
+        title: Optional[None] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        titleAngle: Optional[float] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[Orient_T | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(HeaderConfig, self).__init__(
+        super().__init__(
             format=format,
             formatType=formatType,
             labelAlign=labelAlign,
@@ -15350,7 +8814,7 @@ class HexColor(Color):
     _schema = {"$ref": "#/definitions/HexColor"}
 
     def __init__(self, *args):
-        super(HexColor, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ImputeMethod(VegaLiteSchema):
@@ -15359,7 +8823,7 @@ class ImputeMethod(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ImputeMethod"}
 
     def __init__(self, *args):
-        super(ImputeMethod, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ImputeParams(VegaLiteSchema):
@@ -15402,17 +8866,13 @@ class ImputeParams(VegaLiteSchema):
 
     def __init__(
         self,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        keyvals: Union[dict, "SchemaBase", Sequence[Any], UndefinedType] = Undefined,
-        method: Union[
-            "SchemaBase",
-            Literal["value", "median", "max", "min", "mean"],
-            UndefinedType,
-        ] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        keyvals: Optional[dict | SchemaBase | Sequence[Any]] = Undefined,
+        method: Optional[SchemaBase | ImputeMethod_T] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
     ):
-        super(ImputeParams, self).__init__(
+        super().__init__(
             frame=frame, keyvals=keyvals, method=method, value=value, **kwds
         )
 
@@ -15436,12 +8896,12 @@ class ImputeSequence(VegaLiteSchema):
 
     def __init__(
         self,
-        stop: Union[float, UndefinedType] = Undefined,
-        start: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
+        stop: Optional[float] = Undefined,
+        start: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
         **kwds,
     ):
-        super(ImputeSequence, self).__init__(stop=stop, start=start, step=step, **kwds)
+        super().__init__(stop=stop, start=start, step=step, **kwds)
 
 
 class InlineData(DataSource):
@@ -15464,23 +8924,20 @@ class InlineData(DataSource):
 
     def __init__(
         self,
-        values: Union[
-            str,
-            dict,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[dict],
-            Sequence[float],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        values: Optional[
+            str
+            | dict
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[dict]
+            | Sequence[float]
+        ] = Undefined,
+        format: Optional[dict | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(InlineData, self).__init__(
-            values=values, format=format, name=name, **kwds
-        )
+        super().__init__(values=values, format=format, name=name, **kwds)
 
 
 class InlineDataset(VegaLiteSchema):
@@ -15489,7 +8946,7 @@ class InlineDataset(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/InlineDataset"}
 
     def __init__(self, *args, **kwds):
-        super(InlineDataset, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Interpolate(VegaLiteSchema):
@@ -15498,7 +8955,7 @@ class Interpolate(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Interpolate"}
 
     def __init__(self, *args):
-        super(Interpolate, self).__init__(*args)
+        super().__init__(*args)
 
 
 class IntervalSelectionConfig(VegaLiteSchema):
@@ -15606,59 +9063,18 @@ class IntervalSelectionConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        type: Union[str, UndefinedType] = Undefined,
-        clear: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        encodings: Union[
-            Sequence[
-                Union[
-                    "SchemaBase",
-                    Literal[
-                        "x",
-                        "y",
-                        "xOffset",
-                        "yOffset",
-                        "x2",
-                        "y2",
-                        "longitude",
-                        "latitude",
-                        "longitude2",
-                        "latitude2",
-                        "theta",
-                        "theta2",
-                        "radius",
-                        "radius2",
-                        "color",
-                        "fill",
-                        "stroke",
-                        "opacity",
-                        "fillOpacity",
-                        "strokeOpacity",
-                        "strokeWidth",
-                        "strokeDash",
-                        "size",
-                        "angle",
-                        "shape",
-                        "key",
-                        "text",
-                        "href",
-                        "url",
-                        "description",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fields: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        mark: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        on: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[
-            "SchemaBase", Literal["global", "union", "intersect"], UndefinedType
-        ] = Undefined,
-        translate: Union[str, bool, UndefinedType] = Undefined,
-        zoom: Union[str, bool, UndefinedType] = Undefined,
+        type: Optional[str] = Undefined,
+        clear: Optional[str | bool | dict | SchemaBase] = Undefined,
+        encodings: Optional[Sequence[SchemaBase | SingleDefUnitChannel_T]] = Undefined,
+        fields: Optional[Sequence[str | SchemaBase]] = Undefined,
+        mark: Optional[dict | SchemaBase] = Undefined,
+        on: Optional[str | dict | SchemaBase] = Undefined,
+        resolve: Optional[SchemaBase | SelectionResolution_T] = Undefined,
+        translate: Optional[str | bool] = Undefined,
+        zoom: Optional[str | bool] = Undefined,
         **kwds,
     ):
-        super(IntervalSelectionConfig, self).__init__(
+        super().__init__(
             type=type,
             clear=clear,
             encodings=encodings,
@@ -15769,58 +9185,17 @@ class IntervalSelectionConfigWithoutType(VegaLiteSchema):
 
     def __init__(
         self,
-        clear: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        encodings: Union[
-            Sequence[
-                Union[
-                    "SchemaBase",
-                    Literal[
-                        "x",
-                        "y",
-                        "xOffset",
-                        "yOffset",
-                        "x2",
-                        "y2",
-                        "longitude",
-                        "latitude",
-                        "longitude2",
-                        "latitude2",
-                        "theta",
-                        "theta2",
-                        "radius",
-                        "radius2",
-                        "color",
-                        "fill",
-                        "stroke",
-                        "opacity",
-                        "fillOpacity",
-                        "strokeOpacity",
-                        "strokeWidth",
-                        "strokeDash",
-                        "size",
-                        "angle",
-                        "shape",
-                        "key",
-                        "text",
-                        "href",
-                        "url",
-                        "description",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fields: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        mark: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        on: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[
-            "SchemaBase", Literal["global", "union", "intersect"], UndefinedType
-        ] = Undefined,
-        translate: Union[str, bool, UndefinedType] = Undefined,
-        zoom: Union[str, bool, UndefinedType] = Undefined,
+        clear: Optional[str | bool | dict | SchemaBase] = Undefined,
+        encodings: Optional[Sequence[SchemaBase | SingleDefUnitChannel_T]] = Undefined,
+        fields: Optional[Sequence[str | SchemaBase]] = Undefined,
+        mark: Optional[dict | SchemaBase] = Undefined,
+        on: Optional[str | dict | SchemaBase] = Undefined,
+        resolve: Optional[SchemaBase | SelectionResolution_T] = Undefined,
+        translate: Optional[str | bool] = Undefined,
+        zoom: Optional[str | bool] = Undefined,
         **kwds,
     ):
-        super(IntervalSelectionConfigWithoutType, self).__init__(
+        super().__init__(
             clear=clear,
             encodings=encodings,
             fields=fields,
@@ -15854,41 +9229,11 @@ class JoinAggregateFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        op: Union[
-            "SchemaBase",
-            Literal[
-                "argmax",
-                "argmin",
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
+        op: Optional[SchemaBase | AggregateOp_T] = Undefined,
+        field: Optional[str | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(JoinAggregateFieldDef, self).__init__(op=op, field=field, **kwds)
+        super().__init__(op=op, field=field, **kwds)
 
 
 class JsonDataFormat(DataFormat):
@@ -15929,14 +9274,12 @@ class JsonDataFormat(DataFormat):
 
     def __init__(
         self,
-        parse: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        property: Union[str, UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
+        parse: Optional[dict | None | SchemaBase] = Undefined,
+        property: Optional[str] = Undefined,
+        type: Optional[str] = Undefined,
         **kwds,
     ):
-        super(JsonDataFormat, self).__init__(
-            parse=parse, property=property, type=type, **kwds
-        )
+        super().__init__(parse=parse, property=property, type=type, **kwds)
 
 
 class LabelOverlap(VegaLiteSchema):
@@ -15945,7 +9288,7 @@ class LabelOverlap(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/LabelOverlap"}
 
     def __init__(self, *args, **kwds):
-        super(LabelOverlap, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LatLongDef(VegaLiteSchema):
@@ -15954,7 +9297,7 @@ class LatLongDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/LatLongDef"}
 
     def __init__(self, *args, **kwds):
-        super(LatLongDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LatLongFieldDef(LatLongDef):
@@ -16117,72 +9460,19 @@ class LatLongFieldDef(LatLongDef):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -16197,8 +9487,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -16213,76 +9503,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[str] = Undefined,
         **kwds,
     ):
-        super(LatLongFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -16313,14 +9540,12 @@ class LayerRepeatMapping(VegaLiteSchema):
 
     def __init__(
         self,
-        layer: Union[Sequence[str], UndefinedType] = Undefined,
-        column: Union[Sequence[str], UndefinedType] = Undefined,
-        row: Union[Sequence[str], UndefinedType] = Undefined,
+        layer: Optional[Sequence[str]] = Undefined,
+        column: Optional[Sequence[str]] = Undefined,
+        row: Optional[Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(LayerRepeatMapping, self).__init__(
-            layer=layer, column=column, row=row, **kwds
-        )
+        super().__init__(layer=layer, column=column, row=row, **kwds)
 
 
 class LayoutAlign(VegaLiteSchema):
@@ -16329,7 +9554,7 @@ class LayoutAlign(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/LayoutAlign"}
 
     def __init__(self, *args):
-        super(LayoutAlign, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Legend(VegaLiteSchema):
@@ -16633,1377 +9858,113 @@ class Legend(VegaLiteSchema):
 
     def __init__(
         self,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        clipHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        direction: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        gradientLength: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gridAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelExpr: Union[str, UndefinedType] = Undefined,
-        labelFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        legendX: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            "SchemaBase",
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        tickMinStep: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        titleAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        type: Union[Literal["symbol", "gradient"], UndefinedType] = Undefined,
-        values: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        labelExpr: Optional[str] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        tickMinStep: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        type: Optional[Literal["symbol", "gradient"]] = Undefined,
+        values: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        zindex: Optional[float] = Undefined,
         **kwds,
     ):
-        super(Legend, self).__init__(
+        super().__init__(
             aria=aria,
             clipHeight=clipHeight,
             columnPadding=columnPadding,
@@ -18080,7 +10041,7 @@ class LegendBinding(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/LegendBinding"}
 
     def __init__(self, *args, **kwds):
-        super(LegendBinding, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LegendConfig(VegaLiteSchema):
@@ -18366,1711 +10327,126 @@ class LegendConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        clipHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        columnPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        columns: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        direction: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        disable: Union[bool, UndefinedType] = Undefined,
-        fillColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientDirection: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["horizontal", "vertical"],
-            UndefinedType,
-        ] = Undefined,
-        gradientHorizontalMaxLength: Union[float, UndefinedType] = Undefined,
-        gradientHorizontalMinLength: Union[float, UndefinedType] = Undefined,
-        gradientLabelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientLabelOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientLength: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientStrokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        gradientStrokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientThickness: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        gradientVerticalMaxLength: Union[float, UndefinedType] = Undefined,
-        gradientVerticalMinLength: Union[float, UndefinedType] = Undefined,
-        gridAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["all", "each", "none"],
-            UndefinedType,
-        ] = Undefined,
-        labelAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        labelBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        labelColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        labelLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelOverlap: Union[
-            str, bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        labelSeparation: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        layout: Union[dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        legendX: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        legendY: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            "SchemaBase",
-            Literal[
-                "none",
-                "left",
-                "right",
-                "top",
-                "bottom",
-                "top-left",
-                "top-right",
-                "bottom-left",
-                "bottom-right",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        rowPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolBaseFillColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolBaseStrokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        symbolDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolDirection: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["horizontal", "vertical"],
-            UndefinedType,
-        ] = Undefined,
-        symbolFillColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolStrokeColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbolStrokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        symbolType: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tickCount: Union[
-            dict,
-            float,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[None, UndefinedType] = Undefined,
-        titleAlign: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        titleAnchor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        titleBaseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        titleLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        titleOrient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        titlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        unselectedOpacity: Union[float, UndefinedType] = Undefined,
-        zindex: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        clipHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columnPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        columns: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        direction: Optional[SchemaBase | Orientation_T] = Undefined,
+        disable: Optional[bool] = Undefined,
+        fillColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        gradientDirection: Optional[
+            dict | Parameter | SchemaBase | Orientation_T
+        ] = Undefined,
+        gradientHorizontalMaxLength: Optional[float] = Undefined,
+        gradientHorizontalMinLength: Optional[float] = Undefined,
+        gradientLabelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientLabelOffset: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientLength: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientStrokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        gradientStrokeWidth: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        gradientThickness: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        gradientVerticalMaxLength: Optional[float] = Undefined,
+        gradientVerticalMinLength: Optional[float] = Undefined,
+        gridAlign: Optional[dict | Parameter | SchemaBase | LayoutAlign_T] = Undefined,
+        labelAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        labelBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        labelColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        labelFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        labelFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        labelLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelOverlap: Optional[str | bool | dict | Parameter | SchemaBase] = Undefined,
+        labelPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        labelSeparation: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        layout: Optional[dict | Parameter | SchemaBase] = Undefined,
+        legendX: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        legendY: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[SchemaBase | LegendOrient_T] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        rowPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolBaseFillColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolBaseStrokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        symbolDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolDirection: Optional[
+            dict | Parameter | SchemaBase | Orientation_T
+        ] = Undefined,
+        symbolFillColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolStrokeColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        symbolStrokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        symbolType: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        tickCount: Optional[
+            dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        title: Optional[None] = Undefined,
+        titleAlign: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        titleAnchor: Optional[
+            dict | Parameter | SchemaBase | TitleAnchor_T
+        ] = Undefined,
+        titleBaseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        titleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        titleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        titleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        titleLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        titleOrient: Optional[dict | Orient_T | Parameter | SchemaBase] = Undefined,
+        titlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        unselectedOpacity: Optional[float] = Undefined,
+        zindex: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(LegendConfig, self).__init__(
+        super().__init__(
             aria=aria,
             clipHeight=clipHeight,
             columnPadding=columnPadding,
@@ -20156,7 +10532,7 @@ class LegendOrient(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/LegendOrient"}
 
     def __init__(self, *args):
-        super(LegendOrient, self).__init__(*args)
+        super().__init__(*args)
 
 
 class LegendResolveMap(VegaLiteSchema):
@@ -20193,42 +10569,20 @@ class LegendResolveMap(VegaLiteSchema):
 
     def __init__(
         self,
-        angle: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        color: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        fill: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        fillOpacity: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        shape: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        size: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        strokeDash: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
+        angle: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        color: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        fill: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        fillOpacity: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        opacity: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        shape: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        size: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        stroke: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        strokeDash: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        strokeOpacity: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        strokeWidth: Optional[SchemaBase | ResolveMode_T] = Undefined,
         **kwds,
     ):
-        super(LegendResolveMap, self).__init__(
+        super().__init__(
             angle=angle,
             color=color,
             fill=fill,
@@ -20256,10 +10610,8 @@ class LegendStreamBinding(LegendBinding):
 
     _schema = {"$ref": "#/definitions/LegendStreamBinding"}
 
-    def __init__(
-        self, legend: Union[str, dict, "SchemaBase", UndefinedType] = Undefined, **kwds
-    ):
-        super(LegendStreamBinding, self).__init__(legend=legend, **kwds)
+    def __init__(self, legend: Optional[str | dict | SchemaBase] = Undefined, **kwds):
+        super().__init__(legend=legend, **kwds)
 
 
 class LineConfig(AnyMarkConfig):
@@ -20643,772 +10995,99 @@ class LineConfig(AnyMarkConfig):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(LineConfig, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -21503,16 +11182,12 @@ class LineString(Geometry):
 
     def __init__(
         self,
-        coordinates: Union[
-            Sequence[Union["SchemaBase", Sequence[float]]], UndefinedType
-        ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        coordinates: Optional[Sequence[SchemaBase | Sequence[float]]] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(LineString, self).__init__(
-            coordinates=coordinates, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(coordinates=coordinates, type=type, bbox=bbox, **kwds)
 
 
 class LinearGradient(Gradient):
@@ -21549,16 +11224,16 @@ class LinearGradient(Gradient):
 
     def __init__(
         self,
-        gradient: Union[str, UndefinedType] = Undefined,
-        stops: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        id: Union[str, UndefinedType] = Undefined,
-        x1: Union[float, UndefinedType] = Undefined,
-        x2: Union[float, UndefinedType] = Undefined,
-        y1: Union[float, UndefinedType] = Undefined,
-        y2: Union[float, UndefinedType] = Undefined,
+        gradient: Optional[str] = Undefined,
+        stops: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        id: Optional[str] = Undefined,
+        x1: Optional[float] = Undefined,
+        x2: Optional[float] = Undefined,
+        y1: Optional[float] = Undefined,
+        y2: Optional[float] = Undefined,
         **kwds,
     ):
-        super(LinearGradient, self).__init__(
+        super().__init__(
             gradient=gradient, stops=stops, id=id, x1=x1, x2=x2, y1=y1, y2=y2, **kwds
         )
 
@@ -21579,11 +11254,11 @@ class Locale(VegaLiteSchema):
 
     def __init__(
         self,
-        number: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        time: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        number: Optional[dict | SchemaBase] = Undefined,
+        time: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Locale, self).__init__(number=number, time=time, **kwds)
+        super().__init__(number=number, time=time, **kwds)
 
 
 class LookupData(VegaLiteSchema):
@@ -21605,12 +11280,12 @@ class LookupData(VegaLiteSchema):
 
     def __init__(
         self,
-        data: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        key: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        fields: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
+        data: Optional[dict | SchemaBase] = Undefined,
+        key: Optional[str | SchemaBase] = Undefined,
+        fields: Optional[Sequence[str | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(LookupData, self).__init__(data=data, key=key, fields=fields, **kwds)
+        super().__init__(data=data, key=key, fields=fields, **kwds)
 
 
 class LookupSelection(VegaLiteSchema):
@@ -21632,14 +11307,12 @@ class LookupSelection(VegaLiteSchema):
 
     def __init__(
         self,
-        key: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        fields: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
+        key: Optional[str | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        fields: Optional[Sequence[str | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(LookupSelection, self).__init__(
-            key=key, param=param, fields=fields, **kwds
-        )
+        super().__init__(key=key, param=param, fields=fields, **kwds)
 
 
 class Mark(AnyMark):
@@ -21650,7 +11323,7 @@ class Mark(AnyMark):
     _schema = {"$ref": "#/definitions/Mark"}
 
     def __init__(self, *args):
-        super(Mark, self).__init__(*args)
+        super().__init__(*args)
 
 
 class MarkConfig(AnyMarkConfig):
@@ -22019,771 +11692,98 @@ class MarkConfig(AnyMarkConfig):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(MarkConfig, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -22921,7 +11921,7 @@ class MarkDef(AnyMark):
 
         __Default value:__ ``"source-over"``
     clip : bool, dict, :class:`ExprRef`
-        Whether a mark be clipped to the enclosing group’s width and height.
+        Whether a mark be clipped to the enclosing group's width and height.
     color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']
         Default color.
 
@@ -23319,824 +12319,116 @@ class MarkDef(AnyMark):
 
     def __init__(
         self,
-        type: Union[
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "bar",
-                "image",
-                "line",
-                "point",
-                "rect",
-                "rule",
-                "text",
-                "tick",
-                "trail",
-                "circle",
-                "square",
-                "geoshape",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        type: Optional[Mark_T | SchemaBase] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(MarkDef, self).__init__(
+        super().__init__(
             type=type,
             align=align,
             angle=angle,
@@ -24234,7 +12526,7 @@ class MarkPropDefGradientstringnull(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/MarkPropDef<(Gradient|string|null)>"}
 
     def __init__(self, *args, **kwds):
-        super(MarkPropDefGradientstringnull, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldOrDatumDefWithConditionDatumDefGradientstringnull(
@@ -24355,22 +12647,18 @@ class FieldOrDatumDefWithConditionDatumDefGradientstringnull(
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionDatumDefGradientstringnull, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             condition=condition,
             datum=datum,
@@ -24612,116 +12900,36 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull(
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        legend: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -24736,8 +12944,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -24752,82 +12960,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(
-            FieldOrDatumDefWithConditionMarkPropFieldDefGradientstringnull, self
-        ).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -24850,7 +12989,7 @@ class MarkPropDefnumber(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/MarkPropDef<number>"}
 
     def __init__(self, *args, **kwds):
-        super(MarkPropDefnumber, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class MarkPropDefnumberArray(VegaLiteSchema):
@@ -24859,7 +12998,7 @@ class MarkPropDefnumberArray(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/MarkPropDef<number[]>"}
 
     def __init__(self, *args, **kwds):
-        super(MarkPropDefnumberArray, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class MarkPropDefstringnullTypeForShape(VegaLiteSchema):
@@ -24868,7 +13007,7 @@ class MarkPropDefstringnullTypeForShape(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/MarkPropDef<(string|null),TypeForShape>"}
 
     def __init__(self, *args, **kwds):
-        super(MarkPropDefstringnullTypeForShape, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class MarkType(VegaLiteSchema):
@@ -24877,7 +13016,7 @@ class MarkType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/MarkType"}
 
     def __init__(self, *args):
-        super(MarkType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Month(VegaLiteSchema):
@@ -24886,7 +13025,7 @@ class Month(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Month"}
 
     def __init__(self, *args):
-        super(Month, self).__init__(*args)
+        super().__init__(*args)
 
 
 class MultiLineString(Geometry):
@@ -24909,16 +13048,14 @@ class MultiLineString(Geometry):
 
     def __init__(
         self,
-        coordinates: Union[
-            Sequence[Sequence[Union["SchemaBase", Sequence[float]]]], UndefinedType
+        coordinates: Optional[
+            Sequence[Sequence[SchemaBase | Sequence[float]]]
         ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(MultiLineString, self).__init__(
-            coordinates=coordinates, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(coordinates=coordinates, type=type, bbox=bbox, **kwds)
 
 
 class MultiPoint(Geometry):
@@ -24941,16 +13078,12 @@ class MultiPoint(Geometry):
 
     def __init__(
         self,
-        coordinates: Union[
-            Sequence[Union["SchemaBase", Sequence[float]]], UndefinedType
-        ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        coordinates: Optional[Sequence[SchemaBase | Sequence[float]]] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(MultiPoint, self).__init__(
-            coordinates=coordinates, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(coordinates=coordinates, type=type, bbox=bbox, **kwds)
 
 
 class MultiPolygon(Geometry):
@@ -24973,17 +13106,14 @@ class MultiPolygon(Geometry):
 
     def __init__(
         self,
-        coordinates: Union[
-            Sequence[Sequence[Sequence[Union["SchemaBase", Sequence[float]]]]],
-            UndefinedType,
+        coordinates: Optional[
+            Sequence[Sequence[Sequence[SchemaBase | Sequence[float]]]]
         ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(MultiPolygon, self).__init__(
-            coordinates=coordinates, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(coordinates=coordinates, type=type, bbox=bbox, **kwds)
 
 
 class NamedData(DataSource):
@@ -25007,11 +13137,11 @@ class NamedData(DataSource):
 
     def __init__(
         self,
-        name: Union[str, UndefinedType] = Undefined,
-        format: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        name: Optional[str] = Undefined,
+        format: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(NamedData, self).__init__(name=name, format=format, **kwds)
+        super().__init__(name=name, format=format, **kwds)
 
 
 class NonArgAggregateOp(Aggregate):
@@ -25020,7 +13150,7 @@ class NonArgAggregateOp(Aggregate):
     _schema = {"$ref": "#/definitions/NonArgAggregateOp"}
 
     def __init__(self, *args):
-        super(NonArgAggregateOp, self).__init__(*args)
+        super().__init__(*args)
 
 
 class NonNormalizedSpec(VegaLiteSchema):
@@ -25031,7 +13161,7 @@ class NonNormalizedSpec(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/NonNormalizedSpec"}
 
     def __init__(self, *args, **kwds):
-        super(NonNormalizedSpec, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class NumberLocale(VegaLiteSchema):
@@ -25063,17 +13193,17 @@ class NumberLocale(VegaLiteSchema):
 
     def __init__(
         self,
-        currency: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        decimal: Union[str, UndefinedType] = Undefined,
-        grouping: Union[Sequence[float], UndefinedType] = Undefined,
-        thousands: Union[str, UndefinedType] = Undefined,
-        minus: Union[str, UndefinedType] = Undefined,
-        nan: Union[str, UndefinedType] = Undefined,
-        numerals: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        percent: Union[str, UndefinedType] = Undefined,
+        currency: Optional[SchemaBase | Sequence[str]] = Undefined,
+        decimal: Optional[str] = Undefined,
+        grouping: Optional[Sequence[float]] = Undefined,
+        thousands: Optional[str] = Undefined,
+        minus: Optional[str] = Undefined,
+        nan: Optional[str] = Undefined,
+        numerals: Optional[SchemaBase | Sequence[str]] = Undefined,
+        percent: Optional[str] = Undefined,
         **kwds,
     ):
-        super(NumberLocale, self).__init__(
+        super().__init__(
             currency=currency,
             decimal=decimal,
             grouping=grouping,
@@ -25092,7 +13222,7 @@ class NumericArrayMarkPropDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/NumericArrayMarkPropDef"}
 
     def __init__(self, *args, **kwds):
-        super(NumericArrayMarkPropDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldOrDatumDefWithConditionDatumDefnumberArray(
@@ -25211,22 +13341,18 @@ class FieldOrDatumDefWithConditionDatumDefnumberArray(
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionDatumDefnumberArray, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             condition=condition,
             datum=datum,
@@ -25468,116 +13594,36 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray(
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        legend: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -25592,8 +13638,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -25608,80 +13654,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionMarkPropFieldDefnumberArray, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -25704,7 +13683,7 @@ class NumericMarkPropDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/NumericMarkPropDef"}
 
     def __init__(self, *args, **kwds):
-        super(NumericMarkPropDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldOrDatumDefWithConditionDatumDefnumber(MarkPropDefnumber, NumericMarkPropDef):
@@ -25821,22 +13800,18 @@ class FieldOrDatumDefWithConditionDatumDefnumber(MarkPropDefnumber, NumericMarkP
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionDatumDefnumber, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             condition=condition,
             datum=datum,
@@ -26078,116 +14053,36 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefnumber(
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        legend: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -26202,8 +14097,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -26218,80 +14113,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionMarkPropFieldDefnumber, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -26314,7 +14142,7 @@ class OffsetDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/OffsetDef"}
 
     def __init__(self, *args, **kwds):
-        super(OffsetDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class OrderFieldDef(VegaLiteSchema):
@@ -26479,75 +14307,20 @@ class OrderFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            "SchemaBase", Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        sort: Optional[SortOrder_T | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -26562,8 +14335,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -26578,80 +14351,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(OrderFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -26677,14 +14383,8 @@ class OrderOnlyDef(VegaLiteSchema):
 
     _schema = {"$ref": "#/definitions/OrderOnlyDef"}
 
-    def __init__(
-        self,
-        sort: Union[
-            "SchemaBase", Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
-        **kwds,
-    ):
-        super(OrderOnlyDef, self).__init__(sort=sort, **kwds)
+    def __init__(self, sort: Optional[SortOrder_T | SchemaBase] = Undefined, **kwds):
+        super().__init__(sort=sort, **kwds)
 
 
 class OrderValueDef(VegaLiteSchema):
@@ -26710,15 +14410,13 @@ class OrderValueDef(VegaLiteSchema):
 
     def __init__(
         self,
-        value: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(OrderValueDef, self).__init__(value=value, condition=condition, **kwds)
+        super().__init__(value=value, condition=condition, **kwds)
 
 
 class Orient(VegaLiteSchema):
@@ -26727,7 +14425,7 @@ class Orient(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Orient"}
 
     def __init__(self, *args):
-        super(Orient, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Orientation(VegaLiteSchema):
@@ -26736,7 +14434,7 @@ class Orientation(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Orientation"}
 
     def __init__(self, *args):
-        super(Orientation, self).__init__(*args)
+        super().__init__(*args)
 
 
 class OverlayMarkDef(VegaLiteSchema):
@@ -26788,7 +14486,7 @@ class OverlayMarkDef(VegaLiteSchema):
 
         __Default value:__ ``"source-over"``
     clip : bool, dict, :class:`ExprRef`
-        Whether a mark be clipped to the enclosing group’s width and height.
+        Whether a mark be clipped to the enclosing group's width and height.
     color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`Gradient`, :class:`HexColor`, :class:`ColorName`, :class:`LinearGradient`, :class:`RadialGradient`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']
         Default color.
 
@@ -27137,797 +14835,108 @@ class OverlayMarkDef(VegaLiteSchema):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(OverlayMarkDef, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -28017,7 +15026,7 @@ class Padding(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Padding"}
 
     def __init__(self, *args, **kwds):
-        super(Padding, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ParameterExtent(BinExtent):
@@ -28026,7 +15035,7 @@ class ParameterExtent(BinExtent):
     _schema = {"$ref": "#/definitions/ParameterExtent"}
 
     def __init__(self, *args, **kwds):
-        super(ParameterExtent, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ParameterName(VegaLiteSchema):
@@ -28035,7 +15044,7 @@ class ParameterName(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ParameterName"}
 
     def __init__(self, *args):
-        super(ParameterName, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Parse(VegaLiteSchema):
@@ -28044,7 +15053,7 @@ class Parse(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Parse"}
 
     def __init__(self, **kwds):
-        super(Parse, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class ParseValue(VegaLiteSchema):
@@ -28053,7 +15062,7 @@ class ParseValue(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ParseValue"}
 
     def __init__(self, *args, **kwds):
-        super(ParseValue, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Point(Geometry):
@@ -28080,14 +15089,12 @@ class Point(Geometry):
 
     def __init__(
         self,
-        coordinates: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        coordinates: Optional[SchemaBase | Sequence[float]] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(Point, self).__init__(
-            coordinates=coordinates, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(coordinates=coordinates, type=type, bbox=bbox, **kwds)
 
 
 class PointSelectionConfig(VegaLiteSchema):
@@ -28195,58 +15202,17 @@ class PointSelectionConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        type: Union[str, UndefinedType] = Undefined,
-        clear: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        encodings: Union[
-            Sequence[
-                Union[
-                    "SchemaBase",
-                    Literal[
-                        "x",
-                        "y",
-                        "xOffset",
-                        "yOffset",
-                        "x2",
-                        "y2",
-                        "longitude",
-                        "latitude",
-                        "longitude2",
-                        "latitude2",
-                        "theta",
-                        "theta2",
-                        "radius",
-                        "radius2",
-                        "color",
-                        "fill",
-                        "stroke",
-                        "opacity",
-                        "fillOpacity",
-                        "strokeOpacity",
-                        "strokeWidth",
-                        "strokeDash",
-                        "size",
-                        "angle",
-                        "shape",
-                        "key",
-                        "text",
-                        "href",
-                        "url",
-                        "description",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fields: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        nearest: Union[bool, UndefinedType] = Undefined,
-        on: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[
-            "SchemaBase", Literal["global", "union", "intersect"], UndefinedType
-        ] = Undefined,
-        toggle: Union[str, bool, UndefinedType] = Undefined,
+        type: Optional[str] = Undefined,
+        clear: Optional[str | bool | dict | SchemaBase] = Undefined,
+        encodings: Optional[Sequence[SchemaBase | SingleDefUnitChannel_T]] = Undefined,
+        fields: Optional[Sequence[str | SchemaBase]] = Undefined,
+        nearest: Optional[bool] = Undefined,
+        on: Optional[str | dict | SchemaBase] = Undefined,
+        resolve: Optional[SchemaBase | SelectionResolution_T] = Undefined,
+        toggle: Optional[str | bool] = Undefined,
         **kwds,
     ):
-        super(PointSelectionConfig, self).__init__(
+        super().__init__(
             type=type,
             clear=clear,
             encodings=encodings,
@@ -28356,57 +15322,16 @@ class PointSelectionConfigWithoutType(VegaLiteSchema):
 
     def __init__(
         self,
-        clear: Union[str, bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        encodings: Union[
-            Sequence[
-                Union[
-                    "SchemaBase",
-                    Literal[
-                        "x",
-                        "y",
-                        "xOffset",
-                        "yOffset",
-                        "x2",
-                        "y2",
-                        "longitude",
-                        "latitude",
-                        "longitude2",
-                        "latitude2",
-                        "theta",
-                        "theta2",
-                        "radius",
-                        "radius2",
-                        "color",
-                        "fill",
-                        "stroke",
-                        "opacity",
-                        "fillOpacity",
-                        "strokeOpacity",
-                        "strokeWidth",
-                        "strokeDash",
-                        "size",
-                        "angle",
-                        "shape",
-                        "key",
-                        "text",
-                        "href",
-                        "url",
-                        "description",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fields: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        nearest: Union[bool, UndefinedType] = Undefined,
-        on: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[
-            "SchemaBase", Literal["global", "union", "intersect"], UndefinedType
-        ] = Undefined,
-        toggle: Union[str, bool, UndefinedType] = Undefined,
+        clear: Optional[str | bool | dict | SchemaBase] = Undefined,
+        encodings: Optional[Sequence[SchemaBase | SingleDefUnitChannel_T]] = Undefined,
+        fields: Optional[Sequence[str | SchemaBase]] = Undefined,
+        nearest: Optional[bool] = Undefined,
+        on: Optional[str | dict | SchemaBase] = Undefined,
+        resolve: Optional[SchemaBase | SelectionResolution_T] = Undefined,
+        toggle: Optional[str | bool] = Undefined,
         **kwds,
     ):
-        super(PointSelectionConfigWithoutType, self).__init__(
+        super().__init__(
             clear=clear,
             encodings=encodings,
             fields=fields,
@@ -28424,7 +15349,7 @@ class PolarDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/PolarDef"}
 
     def __init__(self, *args, **kwds):
-        super(PolarDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Polygon(Geometry):
@@ -28447,16 +15372,14 @@ class Polygon(Geometry):
 
     def __init__(
         self,
-        coordinates: Union[
-            Sequence[Sequence[Union["SchemaBase", Sequence[float]]]], UndefinedType
+        coordinates: Optional[
+            Sequence[Sequence[SchemaBase | Sequence[float]]]
         ] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
-        bbox: Union["SchemaBase", Sequence[float], UndefinedType] = Undefined,
+        type: Optional[str] = Undefined,
+        bbox: Optional[SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(Polygon, self).__init__(
-            coordinates=coordinates, type=type, bbox=bbox, **kwds
-        )
+        super().__init__(coordinates=coordinates, type=type, bbox=bbox, **kwds)
 
 
 class Position(VegaLiteSchema):
@@ -28470,7 +15393,7 @@ class Position(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Position"}
 
     def __init__(self, *args):
-        super(Position, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Position2Def(VegaLiteSchema):
@@ -28479,7 +15402,7 @@ class Position2Def(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Position2Def"}
 
     def __init__(self, *args, **kwds):
-        super(Position2Def, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class DatumDef(LatLongDef, Position2Def):
@@ -28589,19 +15512,15 @@ class DatumDef(LatLongDef, Position2Def):
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(DatumDef, self).__init__(
+        super().__init__(
             bandPosition=bandPosition, datum=datum, title=title, type=type, **kwds
         )
 
@@ -28757,27 +15676,17 @@ class PositionDatumDefBase(PolarDef):
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            "SchemaBase",
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(PositionDatumDefBase, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             datum=datum,
             scale=scale,
@@ -28794,7 +15703,7 @@ class PositionDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/PositionDef"}
 
     def __init__(self, *args, **kwds):
-        super(PositionDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class PositionDatumDef(PositionDef):
@@ -28965,29 +15874,19 @@ class PositionDatumDef(PositionDef):
 
     def __init__(
         self,
-        axis: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        impute: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            "SchemaBase",
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
-        ] = Undefined,
+        axis: Optional[dict | None | SchemaBase] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        impute: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(PositionDatumDef, self).__init__(
+        super().__init__(
             axis=axis,
             bandPosition=bandPosition,
             datum=datum,
@@ -29260,121 +16159,35 @@ class PositionFieldDef(PositionDef):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        axis: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        impute: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            "SchemaBase",
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        axis: Optional[dict | None | SchemaBase] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        impute: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -29389,8 +16202,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -29405,80 +16218,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(PositionFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             axis=axis,
@@ -29739,119 +16485,33 @@ class PositionFieldDefBase(PolarDef):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        stack: Union[
-            bool,
-            None,
-            "SchemaBase",
-            Literal["zero", "center", "normalize"],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        stack: Optional[bool | None | SchemaBase | StackOffset_T] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -29866,8 +16526,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -29882,80 +16542,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(PositionFieldDefBase, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -29989,12 +16582,10 @@ class PositionValueDef(PolarDef, Position2Def, PositionDef):
 
     def __init__(
         self,
-        value: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        value: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(PositionValueDef, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 class PredicateComposition(VegaLiteSchema):
@@ -30003,7 +16594,7 @@ class PredicateComposition(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/PredicateComposition"}
 
     def __init__(self, *args, **kwds):
-        super(PredicateComposition, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LogicalAndPredicate(PredicateComposition):
@@ -30019,7 +16610,7 @@ class LogicalAndPredicate(PredicateComposition):
     _schema = {"$ref": "#/definitions/LogicalAnd<Predicate>"}
 
     def __init__(self, **kwds):
-        super(LogicalAndPredicate, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class LogicalNotPredicate(PredicateComposition):
@@ -30035,7 +16626,7 @@ class LogicalNotPredicate(PredicateComposition):
     _schema = {"$ref": "#/definitions/LogicalNot<Predicate>"}
 
     def __init__(self, **kwds):
-        super(LogicalNotPredicate, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class LogicalOrPredicate(PredicateComposition):
@@ -30051,7 +16642,7 @@ class LogicalOrPredicate(PredicateComposition):
     _schema = {"$ref": "#/definitions/LogicalOr<Predicate>"}
 
     def __init__(self, **kwds):
-        super(LogicalOrPredicate, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class Predicate(PredicateComposition):
@@ -30060,7 +16651,7 @@ class Predicate(PredicateComposition):
     _schema = {"$ref": "#/definitions/Predicate"}
 
     def __init__(self, *args, **kwds):
-        super(Predicate, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldEqualPredicate(Predicate):
@@ -30081,40 +16672,16 @@ class FieldEqualPredicate(Predicate):
 
     def __init__(
         self,
-        equal: Union[
-            str, bool, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        equal: Optional[str | bool | dict | float | Parameter | SchemaBase] = Undefined,
+        field: Optional[str | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -30129,8 +16696,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30145,76 +16712,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldEqualPredicate, self).__init__(
-            equal=equal, field=field, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(equal=equal, field=field, timeUnit=timeUnit, **kwds)
 
 
 class FieldGTEPredicate(Predicate):
@@ -30235,40 +16737,16 @@ class FieldGTEPredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        gte: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        gte: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -30283,8 +16761,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30299,76 +16777,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldGTEPredicate, self).__init__(
-            field=field, gte=gte, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, gte=gte, timeUnit=timeUnit, **kwds)
 
 
 class FieldGTPredicate(Predicate):
@@ -30389,40 +16802,16 @@ class FieldGTPredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        gt: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        gt: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -30437,8 +16826,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30453,76 +16842,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldGTPredicate, self).__init__(
-            field=field, gt=gt, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, gt=gt, timeUnit=timeUnit, **kwds)
 
 
 class FieldLTEPredicate(Predicate):
@@ -30543,40 +16867,16 @@ class FieldLTEPredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        lte: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        lte: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -30591,8 +16891,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30607,76 +16907,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldLTEPredicate, self).__init__(
-            field=field, lte=lte, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, lte=lte, timeUnit=timeUnit, **kwds)
 
 
 class FieldLTPredicate(Predicate):
@@ -30697,40 +16932,16 @@ class FieldLTPredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        lt: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        lt: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -30745,8 +16956,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30761,76 +16972,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldLTPredicate, self).__init__(
-            field=field, lt=lt, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, lt=lt, timeUnit=timeUnit, **kwds)
 
 
 class FieldOneOfPredicate(Predicate):
@@ -30852,44 +16998,21 @@ class FieldOneOfPredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        oneOf: Union[
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        oneOf: Optional[
+            Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -30904,8 +17027,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -30920,76 +17043,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldOneOfPredicate, self).__init__(
-            field=field, oneOf=oneOf, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, oneOf=oneOf, timeUnit=timeUnit, **kwds)
 
 
 class FieldRangePredicate(Predicate):
@@ -31011,44 +17069,21 @@ class FieldRangePredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        range: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union[dict, None, float, "_Parameter", "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -31063,8 +17098,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -31079,76 +17114,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldRangePredicate, self).__init__(
-            field=field, range=range, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, range=range, timeUnit=timeUnit, **kwds)
 
 
 class FieldValidPredicate(Predicate):
@@ -31171,38 +17141,16 @@ class FieldValidPredicate(Predicate):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        valid: Union[bool, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        field: Optional[str | SchemaBase] = Undefined,
+        valid: Optional[bool] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -31217,8 +17165,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -31233,76 +17181,11 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+            ]
         ] = Undefined,
         **kwds,
     ):
-        super(FieldValidPredicate, self).__init__(
-            field=field, valid=valid, timeUnit=timeUnit, **kwds
-        )
+        super().__init__(field=field, valid=valid, timeUnit=timeUnit, **kwds)
 
 
 class ParameterPredicate(Predicate):
@@ -31322,11 +17205,11 @@ class ParameterPredicate(Predicate):
 
     def __init__(
         self,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        empty: Union[bool, UndefinedType] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
+        empty: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ParameterPredicate, self).__init__(param=param, empty=empty, **kwds)
+        super().__init__(param=param, empty=empty, **kwds)
 
 
 class Projection(VegaLiteSchema):
@@ -31354,7 +17237,7 @@ class Projection(VegaLiteSchema):
         **Default value:** ``2``
     distance : dict, float, :class:`ExprRef`
         For the ``satellite`` projection, the distance from the center of the sphere to the
-        point of view, as a proportion of the sphere’s radius. The recommended maximum clip
+        point of view, as a proportion of the sphere's radius. The recommended maximum clip
         angle for a given ``distance`` is acos(1 / distance) converted to degrees. If tilt
         is also applied, then more conservative clipping may be necessary.
 
@@ -31389,7 +17272,7 @@ class Projection(VegaLiteSchema):
     precision : dict, float, :class:`ExprRef`
         The threshold for the projection's `adaptive resampling
         <http://bl.ocks.org/mbostock/3795544>`__ to the specified value in pixels. This
-        value corresponds to the `Douglas–Peucker distance
+        value corresponds to the `Douglas-Peucker distance
         <http://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm>`__.
         If precision is not specified, returns the projection's current resampling precision
         which defaults to ``√0.5 ≅ 0.70710…``.
@@ -31411,7 +17294,7 @@ class Projection(VegaLiteSchema):
 
         **Default value:** ``[0, 0, 0]``
     scale : dict, float, :class:`ExprRef`
-        The projection’s scale (zoom) factor, overriding automatic fitting. The default
+        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.
@@ -31427,7 +17310,7 @@ class Projection(VegaLiteSchema):
 
         **Default value:** ``0``.
     translate : dict, Sequence[float], :class:`ExprRef`, :class:`Vector2number`
-        The projection’s translation offset as a two-element array ``[tx, ty]``.
+        The projection's translation offset as a two-element array ``[tx, ty]``.
     type : dict, :class:`ExprRef`, :class:`ProjectionType`, Literal['albers', 'albersUsa', 'azimuthalEqualArea', 'azimuthalEquidistant', 'conicConformal', 'conicEqualArea', 'conicEquidistant', 'equalEarth', 'equirectangular', 'gnomonic', 'identity', 'mercator', 'naturalEarth1', 'orthographic', 'stereographic', 'transverseMercator']
         The cartographic projection to use. This value is case-insensitive, for example
         ``"albers"`` and ``"Albers"`` indicate the same projection type. You can find all
@@ -31441,113 +17324,47 @@ class Projection(VegaLiteSchema):
 
     def __init__(
         self,
-        center: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        clipAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        clipExtent: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union["SchemaBase", Sequence[float]]],
-            UndefinedType,
-        ] = Undefined,
-        coefficient: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        distance: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        extent: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union["SchemaBase", Sequence[float]]],
-            UndefinedType,
-        ] = Undefined,
-        fit: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union[dict, "SchemaBase"]],
-            Sequence[Union[dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]]]],
-            UndefinedType,
-        ] = Undefined,
-        fraction: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lobes: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        parallel: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        parallels: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        pointRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        precision: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ratio: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        reflectX: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        reflectY: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        rotate: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        scale: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        spacing: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tilt: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        translate: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        type: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "albers",
-                "albersUsa",
-                "azimuthalEqualArea",
-                "azimuthalEquidistant",
-                "conicConformal",
-                "conicEqualArea",
-                "conicEquidistant",
-                "equalEarth",
-                "equirectangular",
-                "gnomonic",
-                "identity",
-                "mercator",
-                "naturalEarth1",
-                "orthographic",
-                "stereographic",
-                "transverseMercator",
-            ],
-            UndefinedType,
-        ] = Undefined,
+        center: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        clipAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        clipExtent: Optional[
+            dict | Parameter | SchemaBase | Sequence[SchemaBase | Sequence[float]]
+        ] = Undefined,
+        coefficient: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        distance: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        extent: Optional[
+            dict | Parameter | SchemaBase | Sequence[SchemaBase | Sequence[float]]
+        ] = Undefined,
+        fit: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[dict | SchemaBase]
+            | Sequence[dict | SchemaBase | Sequence[dict | SchemaBase]]
+        ] = Undefined,
+        fraction: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lobes: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        parallel: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        parallels: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        pointRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        precision: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ratio: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        reflectX: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        reflectY: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        rotate: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        scale: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        spacing: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tilt: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        type: Optional[dict | Parameter | SchemaBase | ProjectionType_T] = Undefined,
         **kwds,
     ):
-        super(Projection, self).__init__(
+        super().__init__(
             center=center,
             clipAngle=clipAngle,
             clipExtent=clipExtent,
@@ -31601,7 +17418,7 @@ class ProjectionConfig(VegaLiteSchema):
         **Default value:** ``2``
     distance : dict, float, :class:`ExprRef`
         For the ``satellite`` projection, the distance from the center of the sphere to the
-        point of view, as a proportion of the sphere’s radius. The recommended maximum clip
+        point of view, as a proportion of the sphere's radius. The recommended maximum clip
         angle for a given ``distance`` is acos(1 / distance) converted to degrees. If tilt
         is also applied, then more conservative clipping may be necessary.
 
@@ -31636,7 +17453,7 @@ class ProjectionConfig(VegaLiteSchema):
     precision : dict, float, :class:`ExprRef`
         The threshold for the projection's `adaptive resampling
         <http://bl.ocks.org/mbostock/3795544>`__ to the specified value in pixels. This
-        value corresponds to the `Douglas–Peucker distance
+        value corresponds to the `Douglas-Peucker distance
         <http://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm>`__.
         If precision is not specified, returns the projection's current resampling precision
         which defaults to ``√0.5 ≅ 0.70710…``.
@@ -31658,7 +17475,7 @@ class ProjectionConfig(VegaLiteSchema):
 
         **Default value:** ``[0, 0, 0]``
     scale : dict, float, :class:`ExprRef`
-        The projection’s scale (zoom) factor, overriding automatic fitting. The default
+        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.
@@ -31674,7 +17491,7 @@ class ProjectionConfig(VegaLiteSchema):
 
         **Default value:** ``0``.
     translate : dict, Sequence[float], :class:`ExprRef`, :class:`Vector2number`
-        The projection’s translation offset as a two-element array ``[tx, ty]``.
+        The projection's translation offset as a two-element array ``[tx, ty]``.
     type : dict, :class:`ExprRef`, :class:`ProjectionType`, Literal['albers', 'albersUsa', 'azimuthalEqualArea', 'azimuthalEquidistant', 'conicConformal', 'conicEqualArea', 'conicEquidistant', 'equalEarth', 'equirectangular', 'gnomonic', 'identity', 'mercator', 'naturalEarth1', 'orthographic', 'stereographic', 'transverseMercator']
         The cartographic projection to use. This value is case-insensitive, for example
         ``"albers"`` and ``"Albers"`` indicate the same projection type. You can find all
@@ -31688,113 +17505,47 @@ class ProjectionConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        center: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        clipAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        clipExtent: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union["SchemaBase", Sequence[float]]],
-            UndefinedType,
-        ] = Undefined,
-        coefficient: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        distance: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        extent: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union["SchemaBase", Sequence[float]]],
-            UndefinedType,
-        ] = Undefined,
-        fit: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union[dict, "SchemaBase"]],
-            Sequence[Union[dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]]]],
-            UndefinedType,
-        ] = Undefined,
-        fraction: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lobes: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        parallel: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        parallels: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        pointRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        precision: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ratio: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        reflectX: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        reflectY: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        rotate: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        scale: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        spacing: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tilt: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        translate: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        type: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "albers",
-                "albersUsa",
-                "azimuthalEqualArea",
-                "azimuthalEquidistant",
-                "conicConformal",
-                "conicEqualArea",
-                "conicEquidistant",
-                "equalEarth",
-                "equirectangular",
-                "gnomonic",
-                "identity",
-                "mercator",
-                "naturalEarth1",
-                "orthographic",
-                "stereographic",
-                "transverseMercator",
-            ],
-            UndefinedType,
-        ] = Undefined,
+        center: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        clipAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        clipExtent: Optional[
+            dict | Parameter | SchemaBase | Sequence[SchemaBase | Sequence[float]]
+        ] = Undefined,
+        coefficient: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        distance: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        extent: Optional[
+            dict | Parameter | SchemaBase | Sequence[SchemaBase | Sequence[float]]
+        ] = Undefined,
+        fit: Optional[
+            dict
+            | Parameter
+            | SchemaBase
+            | Sequence[dict | SchemaBase]
+            | Sequence[dict | SchemaBase | Sequence[dict | SchemaBase]]
+        ] = Undefined,
+        fraction: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lobes: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        parallel: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        parallels: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        pointRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        precision: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ratio: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        reflectX: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        reflectY: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        rotate: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        scale: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
+        spacing: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tilt: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        translate: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        type: Optional[dict | Parameter | SchemaBase | ProjectionType_T] = Undefined,
         **kwds,
     ):
-        super(ProjectionConfig, self).__init__(
+        super().__init__(
             center=center,
             clipAngle=clipAngle,
             clipExtent=clipExtent,
@@ -31829,7 +17580,7 @@ class ProjectionType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ProjectionType"}
 
     def __init__(self, *args):
-        super(ProjectionType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class RadialGradient(Gradient):
@@ -31880,18 +17631,18 @@ class RadialGradient(Gradient):
 
     def __init__(
         self,
-        gradient: Union[str, UndefinedType] = Undefined,
-        stops: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        id: Union[str, UndefinedType] = Undefined,
-        r1: Union[float, UndefinedType] = Undefined,
-        r2: Union[float, UndefinedType] = Undefined,
-        x1: Union[float, UndefinedType] = Undefined,
-        x2: Union[float, UndefinedType] = Undefined,
-        y1: Union[float, UndefinedType] = Undefined,
-        y2: Union[float, UndefinedType] = Undefined,
+        gradient: Optional[str] = Undefined,
+        stops: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        id: Optional[str] = Undefined,
+        r1: Optional[float] = Undefined,
+        r2: Optional[float] = Undefined,
+        x1: Optional[float] = Undefined,
+        x2: Optional[float] = Undefined,
+        y1: Optional[float] = Undefined,
+        y2: Optional[float] = Undefined,
         **kwds,
     ):
-        super(RadialGradient, self).__init__(
+        super().__init__(
             gradient=gradient,
             stops=stops,
             id=id,
@@ -31935,870 +17686,45 @@ class RangeConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        category: Union[
-            dict,
-            "SchemaBase",
-            Sequence[Union[str, bool, None, float, "SchemaBase", Sequence[float]]],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            Sequence[
-                Union[
-                    str,
-                    "SchemaBase",
-                    Literal[
-                        "black",
-                        "silver",
-                        "gray",
-                        "white",
-                        "maroon",
-                        "red",
-                        "purple",
-                        "fuchsia",
-                        "green",
-                        "lime",
-                        "olive",
-                        "yellow",
-                        "navy",
-                        "blue",
-                        "teal",
-                        "aqua",
-                        "orange",
-                        "aliceblue",
-                        "antiquewhite",
-                        "aquamarine",
-                        "azure",
-                        "beige",
-                        "bisque",
-                        "blanchedalmond",
-                        "blueviolet",
-                        "brown",
-                        "burlywood",
-                        "cadetblue",
-                        "chartreuse",
-                        "chocolate",
-                        "coral",
-                        "cornflowerblue",
-                        "cornsilk",
-                        "crimson",
-                        "cyan",
-                        "darkblue",
-                        "darkcyan",
-                        "darkgoldenrod",
-                        "darkgray",
-                        "darkgreen",
-                        "darkgrey",
-                        "darkkhaki",
-                        "darkmagenta",
-                        "darkolivegreen",
-                        "darkorange",
-                        "darkorchid",
-                        "darkred",
-                        "darksalmon",
-                        "darkseagreen",
-                        "darkslateblue",
-                        "darkslategray",
-                        "darkslategrey",
-                        "darkturquoise",
-                        "darkviolet",
-                        "deeppink",
-                        "deepskyblue",
-                        "dimgray",
-                        "dimgrey",
-                        "dodgerblue",
-                        "firebrick",
-                        "floralwhite",
-                        "forestgreen",
-                        "gainsboro",
-                        "ghostwhite",
-                        "gold",
-                        "goldenrod",
-                        "greenyellow",
-                        "grey",
-                        "honeydew",
-                        "hotpink",
-                        "indianred",
-                        "indigo",
-                        "ivory",
-                        "khaki",
-                        "lavender",
-                        "lavenderblush",
-                        "lawngreen",
-                        "lemonchiffon",
-                        "lightblue",
-                        "lightcoral",
-                        "lightcyan",
-                        "lightgoldenrodyellow",
-                        "lightgray",
-                        "lightgreen",
-                        "lightgrey",
-                        "lightpink",
-                        "lightsalmon",
-                        "lightseagreen",
-                        "lightskyblue",
-                        "lightslategray",
-                        "lightslategrey",
-                        "lightsteelblue",
-                        "lightyellow",
-                        "limegreen",
-                        "linen",
-                        "magenta",
-                        "mediumaquamarine",
-                        "mediumblue",
-                        "mediumorchid",
-                        "mediumpurple",
-                        "mediumseagreen",
-                        "mediumslateblue",
-                        "mediumspringgreen",
-                        "mediumturquoise",
-                        "mediumvioletred",
-                        "midnightblue",
-                        "mintcream",
-                        "mistyrose",
-                        "moccasin",
-                        "navajowhite",
-                        "oldlace",
-                        "olivedrab",
-                        "orangered",
-                        "orchid",
-                        "palegoldenrod",
-                        "palegreen",
-                        "paleturquoise",
-                        "palevioletred",
-                        "papayawhip",
-                        "peachpuff",
-                        "peru",
-                        "pink",
-                        "plum",
-                        "powderblue",
-                        "rosybrown",
-                        "royalblue",
-                        "saddlebrown",
-                        "salmon",
-                        "sandybrown",
-                        "seagreen",
-                        "seashell",
-                        "sienna",
-                        "skyblue",
-                        "slateblue",
-                        "slategray",
-                        "slategrey",
-                        "snow",
-                        "springgreen",
-                        "steelblue",
-                        "tan",
-                        "thistle",
-                        "tomato",
-                        "turquoise",
-                        "violet",
-                        "wheat",
-                        "whitesmoke",
-                        "yellowgreen",
-                        "rebeccapurple",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        diverging: Union[
-            dict,
-            "SchemaBase",
-            Sequence[Union[str, bool, None, float, "SchemaBase", Sequence[float]]],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            Sequence[
-                Union[
-                    str,
-                    "SchemaBase",
-                    Literal[
-                        "black",
-                        "silver",
-                        "gray",
-                        "white",
-                        "maroon",
-                        "red",
-                        "purple",
-                        "fuchsia",
-                        "green",
-                        "lime",
-                        "olive",
-                        "yellow",
-                        "navy",
-                        "blue",
-                        "teal",
-                        "aqua",
-                        "orange",
-                        "aliceblue",
-                        "antiquewhite",
-                        "aquamarine",
-                        "azure",
-                        "beige",
-                        "bisque",
-                        "blanchedalmond",
-                        "blueviolet",
-                        "brown",
-                        "burlywood",
-                        "cadetblue",
-                        "chartreuse",
-                        "chocolate",
-                        "coral",
-                        "cornflowerblue",
-                        "cornsilk",
-                        "crimson",
-                        "cyan",
-                        "darkblue",
-                        "darkcyan",
-                        "darkgoldenrod",
-                        "darkgray",
-                        "darkgreen",
-                        "darkgrey",
-                        "darkkhaki",
-                        "darkmagenta",
-                        "darkolivegreen",
-                        "darkorange",
-                        "darkorchid",
-                        "darkred",
-                        "darksalmon",
-                        "darkseagreen",
-                        "darkslateblue",
-                        "darkslategray",
-                        "darkslategrey",
-                        "darkturquoise",
-                        "darkviolet",
-                        "deeppink",
-                        "deepskyblue",
-                        "dimgray",
-                        "dimgrey",
-                        "dodgerblue",
-                        "firebrick",
-                        "floralwhite",
-                        "forestgreen",
-                        "gainsboro",
-                        "ghostwhite",
-                        "gold",
-                        "goldenrod",
-                        "greenyellow",
-                        "grey",
-                        "honeydew",
-                        "hotpink",
-                        "indianred",
-                        "indigo",
-                        "ivory",
-                        "khaki",
-                        "lavender",
-                        "lavenderblush",
-                        "lawngreen",
-                        "lemonchiffon",
-                        "lightblue",
-                        "lightcoral",
-                        "lightcyan",
-                        "lightgoldenrodyellow",
-                        "lightgray",
-                        "lightgreen",
-                        "lightgrey",
-                        "lightpink",
-                        "lightsalmon",
-                        "lightseagreen",
-                        "lightskyblue",
-                        "lightslategray",
-                        "lightslategrey",
-                        "lightsteelblue",
-                        "lightyellow",
-                        "limegreen",
-                        "linen",
-                        "magenta",
-                        "mediumaquamarine",
-                        "mediumblue",
-                        "mediumorchid",
-                        "mediumpurple",
-                        "mediumseagreen",
-                        "mediumslateblue",
-                        "mediumspringgreen",
-                        "mediumturquoise",
-                        "mediumvioletred",
-                        "midnightblue",
-                        "mintcream",
-                        "mistyrose",
-                        "moccasin",
-                        "navajowhite",
-                        "oldlace",
-                        "olivedrab",
-                        "orangered",
-                        "orchid",
-                        "palegoldenrod",
-                        "palegreen",
-                        "paleturquoise",
-                        "palevioletred",
-                        "papayawhip",
-                        "peachpuff",
-                        "peru",
-                        "pink",
-                        "plum",
-                        "powderblue",
-                        "rosybrown",
-                        "royalblue",
-                        "saddlebrown",
-                        "salmon",
-                        "sandybrown",
-                        "seagreen",
-                        "seashell",
-                        "sienna",
-                        "skyblue",
-                        "slateblue",
-                        "slategray",
-                        "slategrey",
-                        "snow",
-                        "springgreen",
-                        "steelblue",
-                        "tan",
-                        "thistle",
-                        "tomato",
-                        "turquoise",
-                        "violet",
-                        "wheat",
-                        "whitesmoke",
-                        "yellowgreen",
-                        "rebeccapurple",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        heatmap: Union[
-            dict,
-            "SchemaBase",
-            Sequence[Union[str, bool, None, float, "SchemaBase", Sequence[float]]],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            Sequence[
-                Union[
-                    str,
-                    "SchemaBase",
-                    Literal[
-                        "black",
-                        "silver",
-                        "gray",
-                        "white",
-                        "maroon",
-                        "red",
-                        "purple",
-                        "fuchsia",
-                        "green",
-                        "lime",
-                        "olive",
-                        "yellow",
-                        "navy",
-                        "blue",
-                        "teal",
-                        "aqua",
-                        "orange",
-                        "aliceblue",
-                        "antiquewhite",
-                        "aquamarine",
-                        "azure",
-                        "beige",
-                        "bisque",
-                        "blanchedalmond",
-                        "blueviolet",
-                        "brown",
-                        "burlywood",
-                        "cadetblue",
-                        "chartreuse",
-                        "chocolate",
-                        "coral",
-                        "cornflowerblue",
-                        "cornsilk",
-                        "crimson",
-                        "cyan",
-                        "darkblue",
-                        "darkcyan",
-                        "darkgoldenrod",
-                        "darkgray",
-                        "darkgreen",
-                        "darkgrey",
-                        "darkkhaki",
-                        "darkmagenta",
-                        "darkolivegreen",
-                        "darkorange",
-                        "darkorchid",
-                        "darkred",
-                        "darksalmon",
-                        "darkseagreen",
-                        "darkslateblue",
-                        "darkslategray",
-                        "darkslategrey",
-                        "darkturquoise",
-                        "darkviolet",
-                        "deeppink",
-                        "deepskyblue",
-                        "dimgray",
-                        "dimgrey",
-                        "dodgerblue",
-                        "firebrick",
-                        "floralwhite",
-                        "forestgreen",
-                        "gainsboro",
-                        "ghostwhite",
-                        "gold",
-                        "goldenrod",
-                        "greenyellow",
-                        "grey",
-                        "honeydew",
-                        "hotpink",
-                        "indianred",
-                        "indigo",
-                        "ivory",
-                        "khaki",
-                        "lavender",
-                        "lavenderblush",
-                        "lawngreen",
-                        "lemonchiffon",
-                        "lightblue",
-                        "lightcoral",
-                        "lightcyan",
-                        "lightgoldenrodyellow",
-                        "lightgray",
-                        "lightgreen",
-                        "lightgrey",
-                        "lightpink",
-                        "lightsalmon",
-                        "lightseagreen",
-                        "lightskyblue",
-                        "lightslategray",
-                        "lightslategrey",
-                        "lightsteelblue",
-                        "lightyellow",
-                        "limegreen",
-                        "linen",
-                        "magenta",
-                        "mediumaquamarine",
-                        "mediumblue",
-                        "mediumorchid",
-                        "mediumpurple",
-                        "mediumseagreen",
-                        "mediumslateblue",
-                        "mediumspringgreen",
-                        "mediumturquoise",
-                        "mediumvioletred",
-                        "midnightblue",
-                        "mintcream",
-                        "mistyrose",
-                        "moccasin",
-                        "navajowhite",
-                        "oldlace",
-                        "olivedrab",
-                        "orangered",
-                        "orchid",
-                        "palegoldenrod",
-                        "palegreen",
-                        "paleturquoise",
-                        "palevioletred",
-                        "papayawhip",
-                        "peachpuff",
-                        "peru",
-                        "pink",
-                        "plum",
-                        "powderblue",
-                        "rosybrown",
-                        "royalblue",
-                        "saddlebrown",
-                        "salmon",
-                        "sandybrown",
-                        "seagreen",
-                        "seashell",
-                        "sienna",
-                        "skyblue",
-                        "slateblue",
-                        "slategray",
-                        "slategrey",
-                        "snow",
-                        "springgreen",
-                        "steelblue",
-                        "tan",
-                        "thistle",
-                        "tomato",
-                        "turquoise",
-                        "violet",
-                        "wheat",
-                        "whitesmoke",
-                        "yellowgreen",
-                        "rebeccapurple",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        ordinal: Union[
-            dict,
-            "SchemaBase",
-            Sequence[Union[str, bool, None, float, "SchemaBase", Sequence[float]]],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            Sequence[
-                Union[
-                    str,
-                    "SchemaBase",
-                    Literal[
-                        "black",
-                        "silver",
-                        "gray",
-                        "white",
-                        "maroon",
-                        "red",
-                        "purple",
-                        "fuchsia",
-                        "green",
-                        "lime",
-                        "olive",
-                        "yellow",
-                        "navy",
-                        "blue",
-                        "teal",
-                        "aqua",
-                        "orange",
-                        "aliceblue",
-                        "antiquewhite",
-                        "aquamarine",
-                        "azure",
-                        "beige",
-                        "bisque",
-                        "blanchedalmond",
-                        "blueviolet",
-                        "brown",
-                        "burlywood",
-                        "cadetblue",
-                        "chartreuse",
-                        "chocolate",
-                        "coral",
-                        "cornflowerblue",
-                        "cornsilk",
-                        "crimson",
-                        "cyan",
-                        "darkblue",
-                        "darkcyan",
-                        "darkgoldenrod",
-                        "darkgray",
-                        "darkgreen",
-                        "darkgrey",
-                        "darkkhaki",
-                        "darkmagenta",
-                        "darkolivegreen",
-                        "darkorange",
-                        "darkorchid",
-                        "darkred",
-                        "darksalmon",
-                        "darkseagreen",
-                        "darkslateblue",
-                        "darkslategray",
-                        "darkslategrey",
-                        "darkturquoise",
-                        "darkviolet",
-                        "deeppink",
-                        "deepskyblue",
-                        "dimgray",
-                        "dimgrey",
-                        "dodgerblue",
-                        "firebrick",
-                        "floralwhite",
-                        "forestgreen",
-                        "gainsboro",
-                        "ghostwhite",
-                        "gold",
-                        "goldenrod",
-                        "greenyellow",
-                        "grey",
-                        "honeydew",
-                        "hotpink",
-                        "indianred",
-                        "indigo",
-                        "ivory",
-                        "khaki",
-                        "lavender",
-                        "lavenderblush",
-                        "lawngreen",
-                        "lemonchiffon",
-                        "lightblue",
-                        "lightcoral",
-                        "lightcyan",
-                        "lightgoldenrodyellow",
-                        "lightgray",
-                        "lightgreen",
-                        "lightgrey",
-                        "lightpink",
-                        "lightsalmon",
-                        "lightseagreen",
-                        "lightskyblue",
-                        "lightslategray",
-                        "lightslategrey",
-                        "lightsteelblue",
-                        "lightyellow",
-                        "limegreen",
-                        "linen",
-                        "magenta",
-                        "mediumaquamarine",
-                        "mediumblue",
-                        "mediumorchid",
-                        "mediumpurple",
-                        "mediumseagreen",
-                        "mediumslateblue",
-                        "mediumspringgreen",
-                        "mediumturquoise",
-                        "mediumvioletred",
-                        "midnightblue",
-                        "mintcream",
-                        "mistyrose",
-                        "moccasin",
-                        "navajowhite",
-                        "oldlace",
-                        "olivedrab",
-                        "orangered",
-                        "orchid",
-                        "palegoldenrod",
-                        "palegreen",
-                        "paleturquoise",
-                        "palevioletred",
-                        "papayawhip",
-                        "peachpuff",
-                        "peru",
-                        "pink",
-                        "plum",
-                        "powderblue",
-                        "rosybrown",
-                        "royalblue",
-                        "saddlebrown",
-                        "salmon",
-                        "sandybrown",
-                        "seagreen",
-                        "seashell",
-                        "sienna",
-                        "skyblue",
-                        "slateblue",
-                        "slategray",
-                        "slategrey",
-                        "snow",
-                        "springgreen",
-                        "steelblue",
-                        "tan",
-                        "thistle",
-                        "tomato",
-                        "turquoise",
-                        "violet",
-                        "wheat",
-                        "whitesmoke",
-                        "yellowgreen",
-                        "rebeccapurple",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        ramp: Union[
-            dict,
-            "SchemaBase",
-            Sequence[Union[str, bool, None, float, "SchemaBase", Sequence[float]]],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            Sequence[
-                Union[
-                    str,
-                    "SchemaBase",
-                    Literal[
-                        "black",
-                        "silver",
-                        "gray",
-                        "white",
-                        "maroon",
-                        "red",
-                        "purple",
-                        "fuchsia",
-                        "green",
-                        "lime",
-                        "olive",
-                        "yellow",
-                        "navy",
-                        "blue",
-                        "teal",
-                        "aqua",
-                        "orange",
-                        "aliceblue",
-                        "antiquewhite",
-                        "aquamarine",
-                        "azure",
-                        "beige",
-                        "bisque",
-                        "blanchedalmond",
-                        "blueviolet",
-                        "brown",
-                        "burlywood",
-                        "cadetblue",
-                        "chartreuse",
-                        "chocolate",
-                        "coral",
-                        "cornflowerblue",
-                        "cornsilk",
-                        "crimson",
-                        "cyan",
-                        "darkblue",
-                        "darkcyan",
-                        "darkgoldenrod",
-                        "darkgray",
-                        "darkgreen",
-                        "darkgrey",
-                        "darkkhaki",
-                        "darkmagenta",
-                        "darkolivegreen",
-                        "darkorange",
-                        "darkorchid",
-                        "darkred",
-                        "darksalmon",
-                        "darkseagreen",
-                        "darkslateblue",
-                        "darkslategray",
-                        "darkslategrey",
-                        "darkturquoise",
-                        "darkviolet",
-                        "deeppink",
-                        "deepskyblue",
-                        "dimgray",
-                        "dimgrey",
-                        "dodgerblue",
-                        "firebrick",
-                        "floralwhite",
-                        "forestgreen",
-                        "gainsboro",
-                        "ghostwhite",
-                        "gold",
-                        "goldenrod",
-                        "greenyellow",
-                        "grey",
-                        "honeydew",
-                        "hotpink",
-                        "indianred",
-                        "indigo",
-                        "ivory",
-                        "khaki",
-                        "lavender",
-                        "lavenderblush",
-                        "lawngreen",
-                        "lemonchiffon",
-                        "lightblue",
-                        "lightcoral",
-                        "lightcyan",
-                        "lightgoldenrodyellow",
-                        "lightgray",
-                        "lightgreen",
-                        "lightgrey",
-                        "lightpink",
-                        "lightsalmon",
-                        "lightseagreen",
-                        "lightskyblue",
-                        "lightslategray",
-                        "lightslategrey",
-                        "lightsteelblue",
-                        "lightyellow",
-                        "limegreen",
-                        "linen",
-                        "magenta",
-                        "mediumaquamarine",
-                        "mediumblue",
-                        "mediumorchid",
-                        "mediumpurple",
-                        "mediumseagreen",
-                        "mediumslateblue",
-                        "mediumspringgreen",
-                        "mediumturquoise",
-                        "mediumvioletred",
-                        "midnightblue",
-                        "mintcream",
-                        "mistyrose",
-                        "moccasin",
-                        "navajowhite",
-                        "oldlace",
-                        "olivedrab",
-                        "orangered",
-                        "orchid",
-                        "palegoldenrod",
-                        "palegreen",
-                        "paleturquoise",
-                        "palevioletred",
-                        "papayawhip",
-                        "peachpuff",
-                        "peru",
-                        "pink",
-                        "plum",
-                        "powderblue",
-                        "rosybrown",
-                        "royalblue",
-                        "saddlebrown",
-                        "salmon",
-                        "sandybrown",
-                        "seagreen",
-                        "seashell",
-                        "sienna",
-                        "skyblue",
-                        "slateblue",
-                        "slategray",
-                        "slategrey",
-                        "snow",
-                        "springgreen",
-                        "steelblue",
-                        "tan",
-                        "thistle",
-                        "tomato",
-                        "turquoise",
-                        "violet",
-                        "wheat",
-                        "whitesmoke",
-                        "yellowgreen",
-                        "rebeccapurple",
-                    ],
-                ]
-            ],
-            UndefinedType,
-        ] = Undefined,
-        symbol: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
+        category: Optional[
+            dict
+            | RangeEnum_T
+            | SchemaBase
+            | Sequence[str | ColorName_T | SchemaBase]
+            | Sequence[str | bool | None | float | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        diverging: Optional[
+            dict
+            | RangeEnum_T
+            | SchemaBase
+            | Sequence[str | ColorName_T | SchemaBase]
+            | Sequence[str | bool | None | float | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        heatmap: Optional[
+            dict
+            | RangeEnum_T
+            | SchemaBase
+            | Sequence[str | ColorName_T | SchemaBase]
+            | Sequence[str | bool | None | float | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        ordinal: Optional[
+            dict
+            | RangeEnum_T
+            | SchemaBase
+            | Sequence[str | ColorName_T | SchemaBase]
+            | Sequence[str | bool | None | float | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        ramp: Optional[
+            dict
+            | RangeEnum_T
+            | SchemaBase
+            | Sequence[str | ColorName_T | SchemaBase]
+            | Sequence[str | bool | None | float | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        symbol: Optional[Sequence[str | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(RangeConfig, self).__init__(
+        super().__init__(
             category=category,
             diverging=diverging,
             heatmap=heatmap,
@@ -32815,7 +17741,7 @@ class RangeRawArray(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/RangeRawArray"}
 
     def __init__(self, *args):
-        super(RangeRawArray, self).__init__(*args)
+        super().__init__(*args)
 
 
 class RangeScheme(VegaLiteSchema):
@@ -32824,7 +17750,7 @@ class RangeScheme(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/RangeScheme"}
 
     def __init__(self, *args, **kwds):
-        super(RangeScheme, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class RangeEnum(RangeScheme):
@@ -32833,7 +17759,7 @@ class RangeEnum(RangeScheme):
     _schema = {"$ref": "#/definitions/RangeEnum"}
 
     def __init__(self, *args):
-        super(RangeEnum, self).__init__(*args)
+        super().__init__(*args)
 
 
 class RangeRaw(RangeScheme):
@@ -32842,7 +17768,7 @@ class RangeRaw(RangeScheme):
     _schema = {"$ref": "#/definitions/RangeRaw"}
 
     def __init__(self, *args):
-        super(RangeRaw, self).__init__(*args)
+        super().__init__(*args)
 
 
 class RectConfig(AnyMarkConfig):
@@ -33225,777 +18151,102 @@ class RectConfig(AnyMarkConfig):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(RectConfig, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -34086,8 +18337,8 @@ class RelativeBandSize(VegaLiteSchema):
 
     _schema = {"$ref": "#/definitions/RelativeBandSize"}
 
-    def __init__(self, band: Union[float, UndefinedType] = Undefined, **kwds):
-        super(RelativeBandSize, self).__init__(band=band, **kwds)
+    def __init__(self, band: Optional[float] = Undefined, **kwds):
+        super().__init__(band=band, **kwds)
 
 
 class RepeatMapping(VegaLiteSchema):
@@ -34106,11 +18357,11 @@ class RepeatMapping(VegaLiteSchema):
 
     def __init__(
         self,
-        column: Union[Sequence[str], UndefinedType] = Undefined,
-        row: Union[Sequence[str], UndefinedType] = Undefined,
+        column: Optional[Sequence[str]] = Undefined,
+        row: Optional[Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(RepeatMapping, self).__init__(column=column, row=row, **kwds)
+        super().__init__(column=column, row=row, **kwds)
 
 
 class RepeatRef(Field):
@@ -34128,12 +18379,10 @@ class RepeatRef(Field):
 
     def __init__(
         self,
-        repeat: Union[
-            Literal["row", "column", "repeat", "layer"], UndefinedType
-        ] = Undefined,
+        repeat: Optional[Literal["row", "column", "repeat", "layer"]] = Undefined,
         **kwds,
     ):
-        super(RepeatRef, self).__init__(repeat=repeat, **kwds)
+        super().__init__(repeat=repeat, **kwds)
 
 
 class Resolve(VegaLiteSchema):
@@ -34157,12 +18406,12 @@ class Resolve(VegaLiteSchema):
 
     def __init__(
         self,
-        axis: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        legend: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        axis: Optional[dict | SchemaBase] = Undefined,
+        legend: Optional[dict | SchemaBase] = Undefined,
+        scale: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Resolve, self).__init__(axis=axis, legend=legend, scale=scale, **kwds)
+        super().__init__(axis=axis, legend=legend, scale=scale, **kwds)
 
 
 class ResolveMode(VegaLiteSchema):
@@ -34171,7 +18420,7 @@ class ResolveMode(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ResolveMode"}
 
     def __init__(self, *args):
-        super(ResolveMode, self).__init__(*args)
+        super().__init__(*args)
 
 
 class RowColLayoutAlign(VegaLiteSchema):
@@ -34190,15 +18439,11 @@ class RowColLayoutAlign(VegaLiteSchema):
 
     def __init__(
         self,
-        column: Union[
-            "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        row: Union[
-            "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
+        column: Optional[SchemaBase | LayoutAlign_T] = Undefined,
+        row: Optional[SchemaBase | LayoutAlign_T] = Undefined,
         **kwds,
     ):
-        super(RowColLayoutAlign, self).__init__(column=column, row=row, **kwds)
+        super().__init__(column=column, row=row, **kwds)
 
 
 class RowColboolean(VegaLiteSchema):
@@ -34217,11 +18462,11 @@ class RowColboolean(VegaLiteSchema):
 
     def __init__(
         self,
-        column: Union[bool, UndefinedType] = Undefined,
-        row: Union[bool, UndefinedType] = Undefined,
+        column: Optional[bool] = Undefined,
+        row: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(RowColboolean, self).__init__(column=column, row=row, **kwds)
+        super().__init__(column=column, row=row, **kwds)
 
 
 class RowColnumber(VegaLiteSchema):
@@ -34240,11 +18485,11 @@ class RowColnumber(VegaLiteSchema):
 
     def __init__(
         self,
-        column: Union[float, UndefinedType] = Undefined,
-        row: Union[float, UndefinedType] = Undefined,
+        column: Optional[float] = Undefined,
+        row: Optional[float] = Undefined,
         **kwds,
     ):
-        super(RowColnumber, self).__init__(column=column, row=row, **kwds)
+        super().__init__(column=column, row=row, **kwds)
 
 
 class RowColumnEncodingFieldDef(VegaLiteSchema):
@@ -34461,89 +18706,33 @@ class RowColumnEncodingFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        header: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        align: Optional[SchemaBase | LayoutAlign_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        center: Optional[bool] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        header: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        spacing: Optional[float] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -34558,8 +18747,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -34574,80 +18763,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(RowColumnEncodingFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             align=align,
@@ -34775,7 +18897,7 @@ class Scale(VegaLiteSchema):
         * **Default value:** ``hcl``
     nice : bool, dict, float, :class:`ExprRef`, :class:`TimeInterval`, :class:`TimeIntervalStep`, Literal['millisecond', 'second', 'minute', 'hour', 'day', 'week', 'month', 'year']
         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
+        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]*.
@@ -34799,9 +18921,9 @@ class Scale(VegaLiteSchema):
         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.
+        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.
@@ -34931,479 +19053,58 @@ class Scale(VegaLiteSchema):
 
     def __init__(
         self,
-        align: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        base: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        bins: Union[dict, "SchemaBase", Sequence[float], UndefinedType] = Undefined,
-        clamp: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        constant: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domain: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[Union[str, bool, dict, None, float, "_Parameter", "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        domainMax: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainMid: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainMin: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        domainRaw: Union[dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        exponent: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "rgb",
-                "lab",
-                "hcl",
-                "hsl",
-                "hsl-long",
-                "hcl-long",
-                "cubehelix",
-                "cubehelix-long",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        nice: Union[
-            bool,
-            dict,
-            float,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        paddingInner: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        paddingOuter: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        range: Union[
-            dict,
-            "SchemaBase",
-            Sequence[
-                Union[str, dict, float, "_Parameter", "SchemaBase", Sequence[float]]
-            ],
-            Literal[
-                "width",
-                "height",
-                "symbol",
-                "category",
-                "ordinal",
-                "ramp",
-                "diverging",
-                "heatmap",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        rangeMax: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        rangeMin: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        reverse: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        round: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        scheme: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Sequence[str],
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal[
-                "linear",
-                "log",
-                "pow",
-                "sqrt",
-                "symlog",
-                "identity",
-                "sequential",
-                "time",
-                "utc",
-                "quantile",
-                "quantize",
-                "threshold",
-                "bin-ordinal",
-                "ordinal",
-                "point",
-                "band",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        zero: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
+        align: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        base: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bins: Optional[dict | SchemaBase | Sequence[float]] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        constant: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domain: Optional[
+            str
+            | dict
+            | Parameter
+            | SchemaBase
+            | Sequence[str | bool | dict | None | float | Parameter | SchemaBase]
+        ] = Undefined,
+        domainMax: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMid: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainMin: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        domainRaw: Optional[dict | Parameter | SchemaBase] = Undefined,
+        exponent: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | ScaleInterpolateEnum_T
+        ] = Undefined,
+        nice: Optional[
+            bool | dict | float | Parameter | SchemaBase | TimeInterval_T
+        ] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        paddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        range: Optional[
+            dict
+            | RangeEnum_T
+            | SchemaBase
+            | Sequence[str | dict | float | Parameter | SchemaBase | Sequence[float]]
+        ] = Undefined,
+        rangeMax: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        rangeMin: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        reverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        scheme: Optional[
+            dict
+            | Cyclical_T
+            | Parameter
+            | Diverging_T
+            | SchemaBase
+            | Categorical_T
+            | Sequence[str]
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        type: Optional[ScaleType_T | SchemaBase] = Undefined,
+        zero: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(Scale, self).__init__(
+        super().__init__(
             align=align,
             base=base,
             bins=bins,
@@ -35438,7 +19139,7 @@ class ScaleBins(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ScaleBins"}
 
     def __init__(self, *args, **kwds):
-        super(ScaleBins, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ScaleBinParams(ScaleBins):
@@ -35463,12 +19164,12 @@ class ScaleBinParams(ScaleBins):
 
     def __init__(
         self,
-        step: Union[float, UndefinedType] = Undefined,
-        start: Union[float, UndefinedType] = Undefined,
-        stop: Union[float, UndefinedType] = Undefined,
+        step: Optional[float] = Undefined,
+        start: Optional[float] = Undefined,
+        stop: Optional[float] = Undefined,
         **kwds,
     ):
-        super(ScaleBinParams, self).__init__(step=step, start=start, stop=stop, **kwds)
+        super().__init__(step=step, start=start, stop=stop, **kwds)
 
 
 class ScaleConfig(VegaLiteSchema):
@@ -35612,58 +19313,48 @@ class ScaleConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        bandPaddingInner: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        bandPaddingOuter: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        bandWithNestedOffsetPaddingInner: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        bandWithNestedOffsetPaddingOuter: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        barBandPaddingInner: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        clamp: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        continuousPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        maxBandSize: Union[float, UndefinedType] = Undefined,
-        maxFontSize: Union[float, UndefinedType] = Undefined,
-        maxOpacity: Union[float, UndefinedType] = Undefined,
-        maxSize: Union[float, UndefinedType] = Undefined,
-        maxStrokeWidth: Union[float, UndefinedType] = Undefined,
-        minBandSize: Union[float, UndefinedType] = Undefined,
-        minFontSize: Union[float, UndefinedType] = Undefined,
-        minOpacity: Union[float, UndefinedType] = Undefined,
-        minSize: Union[float, UndefinedType] = Undefined,
-        minStrokeWidth: Union[float, UndefinedType] = Undefined,
-        offsetBandPaddingInner: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offsetBandPaddingOuter: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        pointPadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        quantileCount: Union[float, UndefinedType] = Undefined,
-        quantizeCount: Union[float, UndefinedType] = Undefined,
-        rectBandPaddingInner: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        round: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        useUnaggregatedDomain: Union[bool, UndefinedType] = Undefined,
-        xReverse: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        zero: Union[bool, UndefinedType] = Undefined,
+        bandPaddingInner: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bandPaddingOuter: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        bandWithNestedOffsetPaddingInner: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        bandWithNestedOffsetPaddingOuter: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        barBandPaddingInner: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        clamp: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        continuousPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        maxBandSize: Optional[float] = Undefined,
+        maxFontSize: Optional[float] = Undefined,
+        maxOpacity: Optional[float] = Undefined,
+        maxSize: Optional[float] = Undefined,
+        maxStrokeWidth: Optional[float] = Undefined,
+        minBandSize: Optional[float] = Undefined,
+        minFontSize: Optional[float] = Undefined,
+        minOpacity: Optional[float] = Undefined,
+        minSize: Optional[float] = Undefined,
+        minStrokeWidth: Optional[float] = Undefined,
+        offsetBandPaddingInner: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        offsetBandPaddingOuter: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        pointPadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        quantileCount: Optional[float] = Undefined,
+        quantizeCount: Optional[float] = Undefined,
+        rectBandPaddingInner: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        round: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        useUnaggregatedDomain: Optional[bool] = Undefined,
+        xReverse: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        zero: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(ScaleConfig, self).__init__(
+        super().__init__(
             bandPaddingInner=bandPaddingInner,
             bandPaddingOuter=bandPaddingOuter,
             bandWithNestedOffsetPaddingInner=bandWithNestedOffsetPaddingInner,
@@ -35815,20 +19506,16 @@ class ScaleDatumDef(OffsetDef):
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        bandPosition: Optional[float] = Undefined,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ScaleDatumDef, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             datum=datum,
             scale=scale,
@@ -36050,112 +19737,32 @@ class ScaleFieldDef(OffsetDef):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -36170,8 +19777,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -36186,80 +19793,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(ScaleFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -36280,7 +19820,7 @@ class ScaleInterpolateEnum(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ScaleInterpolateEnum"}
 
     def __init__(self, *args):
-        super(ScaleInterpolateEnum, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ScaleInterpolateParams(VegaLiteSchema):
@@ -36299,13 +19839,11 @@ class ScaleInterpolateParams(VegaLiteSchema):
 
     def __init__(
         self,
-        type: Union[
-            Literal["rgb", "cubehelix", "cubehelix-long"], UndefinedType
-        ] = Undefined,
-        gamma: Union[float, UndefinedType] = Undefined,
+        type: Optional[Literal["rgb", "cubehelix", "cubehelix-long"]] = Undefined,
+        gamma: Optional[float] = Undefined,
         **kwds,
     ):
-        super(ScaleInterpolateParams, self).__init__(type=type, gamma=gamma, **kwds)
+        super().__init__(type=type, gamma=gamma, **kwds)
 
 
 class ScaleResolveMap(VegaLiteSchema):
@@ -36354,60 +19892,26 @@ class ScaleResolveMap(VegaLiteSchema):
 
     def __init__(
         self,
-        angle: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        color: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        fill: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        fillOpacity: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        radius: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        shape: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        size: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        strokeDash: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        x: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        y: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            "SchemaBase", Literal["independent", "shared"], UndefinedType
-        ] = Undefined,
+        angle: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        color: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        fill: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        fillOpacity: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        opacity: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        radius: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        shape: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        size: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        stroke: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        strokeDash: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        strokeOpacity: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        strokeWidth: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        theta: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        x: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        xOffset: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        y: Optional[SchemaBase | ResolveMode_T] = Undefined,
+        yOffset: Optional[SchemaBase | ResolveMode_T] = Undefined,
         **kwds,
     ):
-        super(ScaleResolveMap, self).__init__(
+        super().__init__(
             angle=angle,
             color=color,
             fill=fill,
@@ -36435,7 +19939,7 @@ class ScaleType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ScaleType"}
 
     def __init__(self, *args):
-        super(ScaleType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SchemeParams(VegaLiteSchema):
@@ -36463,356 +19967,19 @@ class SchemeParams(VegaLiteSchema):
 
     def __init__(
         self,
-        name: Union[
-            "SchemaBase",
-            Literal["rainbow", "sinebow"],
-            Literal[
-                "blues",
-                "tealblues",
-                "teals",
-                "greens",
-                "browns",
-                "greys",
-                "purples",
-                "warmgreys",
-                "reds",
-                "oranges",
-            ],
-            Literal[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            Literal[
-                "blueorange",
-                "blueorange-3",
-                "blueorange-4",
-                "blueorange-5",
-                "blueorange-6",
-                "blueorange-7",
-                "blueorange-8",
-                "blueorange-9",
-                "blueorange-10",
-                "blueorange-11",
-                "brownbluegreen",
-                "brownbluegreen-3",
-                "brownbluegreen-4",
-                "brownbluegreen-5",
-                "brownbluegreen-6",
-                "brownbluegreen-7",
-                "brownbluegreen-8",
-                "brownbluegreen-9",
-                "brownbluegreen-10",
-                "brownbluegreen-11",
-                "purplegreen",
-                "purplegreen-3",
-                "purplegreen-4",
-                "purplegreen-5",
-                "purplegreen-6",
-                "purplegreen-7",
-                "purplegreen-8",
-                "purplegreen-9",
-                "purplegreen-10",
-                "purplegreen-11",
-                "pinkyellowgreen",
-                "pinkyellowgreen-3",
-                "pinkyellowgreen-4",
-                "pinkyellowgreen-5",
-                "pinkyellowgreen-6",
-                "pinkyellowgreen-7",
-                "pinkyellowgreen-8",
-                "pinkyellowgreen-9",
-                "pinkyellowgreen-10",
-                "pinkyellowgreen-11",
-                "purpleorange",
-                "purpleorange-3",
-                "purpleorange-4",
-                "purpleorange-5",
-                "purpleorange-6",
-                "purpleorange-7",
-                "purpleorange-8",
-                "purpleorange-9",
-                "purpleorange-10",
-                "purpleorange-11",
-                "redblue",
-                "redblue-3",
-                "redblue-4",
-                "redblue-5",
-                "redblue-6",
-                "redblue-7",
-                "redblue-8",
-                "redblue-9",
-                "redblue-10",
-                "redblue-11",
-                "redgrey",
-                "redgrey-3",
-                "redgrey-4",
-                "redgrey-5",
-                "redgrey-6",
-                "redgrey-7",
-                "redgrey-8",
-                "redgrey-9",
-                "redgrey-10",
-                "redgrey-11",
-                "redyellowblue",
-                "redyellowblue-3",
-                "redyellowblue-4",
-                "redyellowblue-5",
-                "redyellowblue-6",
-                "redyellowblue-7",
-                "redyellowblue-8",
-                "redyellowblue-9",
-                "redyellowblue-10",
-                "redyellowblue-11",
-                "redyellowgreen",
-                "redyellowgreen-3",
-                "redyellowgreen-4",
-                "redyellowgreen-5",
-                "redyellowgreen-6",
-                "redyellowgreen-7",
-                "redyellowgreen-8",
-                "redyellowgreen-9",
-                "redyellowgreen-10",
-                "redyellowgreen-11",
-                "spectral",
-                "spectral-3",
-                "spectral-4",
-                "spectral-5",
-                "spectral-6",
-                "spectral-7",
-                "spectral-8",
-                "spectral-9",
-                "spectral-10",
-                "spectral-11",
-            ],
-            Literal[
-                "turbo",
-                "viridis",
-                "inferno",
-                "magma",
-                "plasma",
-                "cividis",
-                "bluegreen",
-                "bluegreen-3",
-                "bluegreen-4",
-                "bluegreen-5",
-                "bluegreen-6",
-                "bluegreen-7",
-                "bluegreen-8",
-                "bluegreen-9",
-                "bluepurple",
-                "bluepurple-3",
-                "bluepurple-4",
-                "bluepurple-5",
-                "bluepurple-6",
-                "bluepurple-7",
-                "bluepurple-8",
-                "bluepurple-9",
-                "goldgreen",
-                "goldgreen-3",
-                "goldgreen-4",
-                "goldgreen-5",
-                "goldgreen-6",
-                "goldgreen-7",
-                "goldgreen-8",
-                "goldgreen-9",
-                "goldorange",
-                "goldorange-3",
-                "goldorange-4",
-                "goldorange-5",
-                "goldorange-6",
-                "goldorange-7",
-                "goldorange-8",
-                "goldorange-9",
-                "goldred",
-                "goldred-3",
-                "goldred-4",
-                "goldred-5",
-                "goldred-6",
-                "goldred-7",
-                "goldred-8",
-                "goldred-9",
-                "greenblue",
-                "greenblue-3",
-                "greenblue-4",
-                "greenblue-5",
-                "greenblue-6",
-                "greenblue-7",
-                "greenblue-8",
-                "greenblue-9",
-                "orangered",
-                "orangered-3",
-                "orangered-4",
-                "orangered-5",
-                "orangered-6",
-                "orangered-7",
-                "orangered-8",
-                "orangered-9",
-                "purplebluegreen",
-                "purplebluegreen-3",
-                "purplebluegreen-4",
-                "purplebluegreen-5",
-                "purplebluegreen-6",
-                "purplebluegreen-7",
-                "purplebluegreen-8",
-                "purplebluegreen-9",
-                "purpleblue",
-                "purpleblue-3",
-                "purpleblue-4",
-                "purpleblue-5",
-                "purpleblue-6",
-                "purpleblue-7",
-                "purpleblue-8",
-                "purpleblue-9",
-                "purplered",
-                "purplered-3",
-                "purplered-4",
-                "purplered-5",
-                "purplered-6",
-                "purplered-7",
-                "purplered-8",
-                "purplered-9",
-                "redpurple",
-                "redpurple-3",
-                "redpurple-4",
-                "redpurple-5",
-                "redpurple-6",
-                "redpurple-7",
-                "redpurple-8",
-                "redpurple-9",
-                "yellowgreenblue",
-                "yellowgreenblue-3",
-                "yellowgreenblue-4",
-                "yellowgreenblue-5",
-                "yellowgreenblue-6",
-                "yellowgreenblue-7",
-                "yellowgreenblue-8",
-                "yellowgreenblue-9",
-                "yellowgreen",
-                "yellowgreen-3",
-                "yellowgreen-4",
-                "yellowgreen-5",
-                "yellowgreen-6",
-                "yellowgreen-7",
-                "yellowgreen-8",
-                "yellowgreen-9",
-                "yelloworangebrown",
-                "yelloworangebrown-3",
-                "yelloworangebrown-4",
-                "yelloworangebrown-5",
-                "yelloworangebrown-6",
-                "yelloworangebrown-7",
-                "yelloworangebrown-8",
-                "yelloworangebrown-9",
-                "yelloworangered",
-                "yelloworangered-3",
-                "yelloworangered-4",
-                "yelloworangered-5",
-                "yelloworangered-6",
-                "yelloworangered-7",
-                "yelloworangered-8",
-                "yelloworangered-9",
-                "darkblue",
-                "darkblue-3",
-                "darkblue-4",
-                "darkblue-5",
-                "darkblue-6",
-                "darkblue-7",
-                "darkblue-8",
-                "darkblue-9",
-                "darkgold",
-                "darkgold-3",
-                "darkgold-4",
-                "darkgold-5",
-                "darkgold-6",
-                "darkgold-7",
-                "darkgold-8",
-                "darkgold-9",
-                "darkgreen",
-                "darkgreen-3",
-                "darkgreen-4",
-                "darkgreen-5",
-                "darkgreen-6",
-                "darkgreen-7",
-                "darkgreen-8",
-                "darkgreen-9",
-                "darkmulti",
-                "darkmulti-3",
-                "darkmulti-4",
-                "darkmulti-5",
-                "darkmulti-6",
-                "darkmulti-7",
-                "darkmulti-8",
-                "darkmulti-9",
-                "darkred",
-                "darkred-3",
-                "darkred-4",
-                "darkred-5",
-                "darkred-6",
-                "darkred-7",
-                "darkred-8",
-                "darkred-9",
-                "lightgreyred",
-                "lightgreyred-3",
-                "lightgreyred-4",
-                "lightgreyred-5",
-                "lightgreyred-6",
-                "lightgreyred-7",
-                "lightgreyred-8",
-                "lightgreyred-9",
-                "lightgreyteal",
-                "lightgreyteal-3",
-                "lightgreyteal-4",
-                "lightgreyteal-5",
-                "lightgreyteal-6",
-                "lightgreyteal-7",
-                "lightgreyteal-8",
-                "lightgreyteal-9",
-                "lightmulti",
-                "lightmulti-3",
-                "lightmulti-4",
-                "lightmulti-5",
-                "lightmulti-6",
-                "lightmulti-7",
-                "lightmulti-8",
-                "lightmulti-9",
-                "lightorange",
-                "lightorange-3",
-                "lightorange-4",
-                "lightorange-5",
-                "lightorange-6",
-                "lightorange-7",
-                "lightorange-8",
-                "lightorange-9",
-                "lighttealblue",
-                "lighttealblue-3",
-                "lighttealblue-4",
-                "lighttealblue-5",
-                "lighttealblue-6",
-                "lighttealblue-7",
-                "lighttealblue-8",
-                "lighttealblue-9",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        count: Union[float, UndefinedType] = Undefined,
-        extent: Union[Sequence[float], UndefinedType] = Undefined,
+        name: Optional[
+            Cyclical_T
+            | Diverging_T
+            | SchemaBase
+            | Categorical_T
+            | SequentialMultiHue_T
+            | SequentialSingleHue_T
+        ] = Undefined,
+        count: Optional[float] = Undefined,
+        extent: Optional[Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(SchemeParams, self).__init__(
-            name=name, count=count, extent=extent, **kwds
-        )
+        super().__init__(name=name, count=count, extent=extent, **kwds)
 
 
 class SecondaryFieldDef(Position2Def):
@@ -36908,72 +20075,19 @@ class SecondaryFieldDef(Position2Def):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[None, UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[None] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -36988,8 +20102,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -37004,75 +20118,12 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
+            ]
+        ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(SecondaryFieldDef, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -37112,11 +20163,11 @@ class SelectionConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        interval: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        point: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        interval: Optional[dict | SchemaBase] = Undefined,
+        point: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(SelectionConfig, self).__init__(interval=interval, point=point, **kwds)
+        super().__init__(interval=interval, point=point, **kwds)
 
 
 class SelectionInit(VegaLiteSchema):
@@ -37125,7 +20176,7 @@ class SelectionInit(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SelectionInit"}
 
     def __init__(self, *args, **kwds):
-        super(SelectionInit, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class DateTime(SelectionInit):
@@ -37171,19 +20222,19 @@ class DateTime(SelectionInit):
 
     def __init__(
         self,
-        date: Union[float, UndefinedType] = Undefined,
-        day: Union[str, float, "SchemaBase", UndefinedType] = Undefined,
-        hours: Union[float, UndefinedType] = Undefined,
-        milliseconds: Union[float, UndefinedType] = Undefined,
-        minutes: Union[float, UndefinedType] = Undefined,
-        month: Union[str, float, "SchemaBase", UndefinedType] = Undefined,
-        quarter: Union[float, UndefinedType] = Undefined,
-        seconds: Union[float, UndefinedType] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
-        year: Union[float, UndefinedType] = Undefined,
+        date: Optional[float] = Undefined,
+        day: Optional[str | float | SchemaBase] = Undefined,
+        hours: Optional[float] = Undefined,
+        milliseconds: Optional[float] = Undefined,
+        minutes: Optional[float] = Undefined,
+        month: Optional[str | float | SchemaBase] = Undefined,
+        quarter: Optional[float] = Undefined,
+        seconds: Optional[float] = Undefined,
+        utc: Optional[bool] = Undefined,
+        year: Optional[float] = Undefined,
         **kwds,
     ):
-        super(DateTime, self).__init__(
+        super().__init__(
             date=date,
             day=day,
             hours=hours,
@@ -37204,7 +20255,7 @@ class PrimitiveValue(SelectionInit):
     _schema = {"$ref": "#/definitions/PrimitiveValue"}
 
     def __init__(self, *args):
-        super(PrimitiveValue, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SelectionInitInterval(VegaLiteSchema):
@@ -37213,7 +20264,7 @@ class SelectionInitInterval(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SelectionInitInterval"}
 
     def __init__(self, *args, **kwds):
-        super(SelectionInitInterval, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class SelectionInitIntervalMapping(VegaLiteSchema):
@@ -37222,7 +20273,7 @@ class SelectionInitIntervalMapping(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SelectionInitIntervalMapping"}
 
     def __init__(self, **kwds):
-        super(SelectionInitIntervalMapping, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class SelectionInitMapping(VegaLiteSchema):
@@ -37231,7 +20282,7 @@ class SelectionInitMapping(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SelectionInitMapping"}
 
     def __init__(self, **kwds):
-        super(SelectionInitMapping, self).__init__(**kwds)
+        super().__init__(**kwds)
 
 
 class SelectionParameter(VegaLiteSchema):
@@ -37282,26 +20333,15 @@ class SelectionParameter(VegaLiteSchema):
 
     def __init__(
         self,
-        name: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        select: Union[
-            dict, "SchemaBase", Literal["point", "interval"], UndefinedType
-        ] = Undefined,
-        bind: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            "SchemaBase",
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
+        name: Optional[str | SchemaBase] = Undefined,
+        select: Optional[dict | SchemaBase | SelectionType_T] = Undefined,
+        bind: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[
+            str | bool | dict | None | float | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
         **kwds,
     ):
-        super(SelectionParameter, self).__init__(
-            name=name, select=select, bind=bind, value=value, **kwds
-        )
+        super().__init__(name=name, select=select, bind=bind, value=value, **kwds)
 
 
 class SelectionResolution(VegaLiteSchema):
@@ -37310,7 +20350,7 @@ class SelectionResolution(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SelectionResolution"}
 
     def __init__(self, *args):
-        super(SelectionResolution, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SelectionType(VegaLiteSchema):
@@ -37319,7 +20359,7 @@ class SelectionType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SelectionType"}
 
     def __init__(self, *args):
-        super(SelectionType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SequenceGenerator(Generator):
@@ -37338,11 +20378,11 @@ class SequenceGenerator(Generator):
 
     def __init__(
         self,
-        sequence: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        sequence: Optional[dict | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(SequenceGenerator, self).__init__(sequence=sequence, name=name, **kwds)
+        super().__init__(sequence=sequence, name=name, **kwds)
 
 
 class SequenceParams(VegaLiteSchema):
@@ -37369,12 +20409,12 @@ class SequenceParams(VegaLiteSchema):
 
     def __init__(
         self,
-        start: Union[float, UndefinedType] = Undefined,
-        stop: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
+        start: Optional[float] = Undefined,
+        stop: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
         **kwds,
     ):
-        super(SequenceParams, self).__init__(start=start, stop=stop, step=step, **kwds)
+        super().__init__(start=start, stop=stop, step=step, **kwds)
 
 
 class SequentialMultiHue(ColorScheme):
@@ -37383,7 +20423,7 @@ class SequentialMultiHue(ColorScheme):
     _schema = {"$ref": "#/definitions/SequentialMultiHue"}
 
     def __init__(self, *args):
-        super(SequentialMultiHue, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SequentialSingleHue(ColorScheme):
@@ -37392,7 +20432,7 @@ class SequentialSingleHue(ColorScheme):
     _schema = {"$ref": "#/definitions/SequentialSingleHue"}
 
     def __init__(self, *args):
-        super(SequentialSingleHue, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ShapeDef(VegaLiteSchema):
@@ -37401,7 +20441,7 @@ class ShapeDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/ShapeDef"}
 
     def __init__(self, *args, **kwds):
-        super(ShapeDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldOrDatumDefWithConditionDatumDefstringnull(
@@ -37522,22 +20562,18 @@ class FieldOrDatumDefWithConditionDatumDefstringnull(
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionDatumDefstringnull, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             condition=condition,
             datum=datum,
@@ -37779,116 +20815,36 @@ class FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull(
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        legend: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        scale: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        sort: Union[
-            dict,
-            None,
-            "SchemaBase",
-            Sequence[str],
-            Sequence[bool],
-            Sequence[float],
-            Literal["ascending", "descending"],
-            Sequence[Union[dict, "SchemaBase"]],
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            Literal[
-                "-x",
-                "-y",
-                "-color",
-                "-fill",
-                "-stroke",
-                "-strokeWidth",
-                "-size",
-                "-shape",
-                "-fillOpacity",
-                "-strokeOpacity",
-                "-opacity",
-                "-text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        legend: Optional[dict | None | SchemaBase] = Undefined,
+        scale: Optional[dict | None | SchemaBase] = Undefined,
+        sort: Optional[
+            dict
+            | None
+            | SortOrder_T
+            | SchemaBase
+            | Sequence[str]
+            | Sequence[bool]
+            | Sequence[float]
+            | SortByChannel_T
+            | SortByChannelDesc_T
+            | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -37903,8 +20859,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -37919,80 +20875,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase", Literal["nominal", "ordinal", "geojson"], UndefinedType
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | TypeForShape_T] = Undefined,
         **kwds,
     ):
-        super(
-            FieldOrDatumDefWithConditionMarkPropFieldDefTypeForShapestringnull, self
-        ).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -38114,52 +21003,48 @@ class SharedEncoding(VegaLiteSchema):
 
     def __init__(
         self,
-        angle: Union[dict, UndefinedType] = Undefined,
-        color: Union[dict, UndefinedType] = Undefined,
-        description: Union[dict, UndefinedType] = Undefined,
-        detail: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        fill: Union[dict, UndefinedType] = Undefined,
-        fillOpacity: Union[dict, UndefinedType] = Undefined,
-        href: Union[dict, UndefinedType] = Undefined,
-        key: Union[dict, UndefinedType] = Undefined,
-        latitude: Union[dict, UndefinedType] = Undefined,
-        latitude2: Union[dict, UndefinedType] = Undefined,
-        longitude: Union[dict, UndefinedType] = Undefined,
-        longitude2: Union[dict, UndefinedType] = Undefined,
-        opacity: Union[dict, UndefinedType] = Undefined,
-        order: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        radius: Union[dict, UndefinedType] = Undefined,
-        radius2: Union[dict, UndefinedType] = Undefined,
-        shape: Union[dict, UndefinedType] = Undefined,
-        size: Union[dict, UndefinedType] = Undefined,
-        stroke: Union[dict, UndefinedType] = Undefined,
-        strokeDash: Union[dict, UndefinedType] = Undefined,
-        strokeOpacity: Union[dict, UndefinedType] = Undefined,
-        strokeWidth: Union[dict, UndefinedType] = Undefined,
-        text: Union[dict, UndefinedType] = Undefined,
-        theta: Union[dict, UndefinedType] = Undefined,
-        theta2: Union[dict, UndefinedType] = Undefined,
-        tooltip: Union[
-            dict, None, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        url: Union[dict, UndefinedType] = Undefined,
-        x: Union[dict, UndefinedType] = Undefined,
-        x2: Union[dict, UndefinedType] = Undefined,
-        xError: Union[dict, UndefinedType] = Undefined,
-        xError2: Union[dict, UndefinedType] = Undefined,
-        xOffset: Union[dict, UndefinedType] = Undefined,
-        y: Union[dict, UndefinedType] = Undefined,
-        y2: Union[dict, UndefinedType] = Undefined,
-        yError: Union[dict, UndefinedType] = Undefined,
-        yError2: Union[dict, UndefinedType] = Undefined,
-        yOffset: Union[dict, UndefinedType] = Undefined,
+        angle: Optional[dict] = Undefined,
+        color: Optional[dict] = Undefined,
+        description: Optional[dict] = Undefined,
+        detail: Optional[dict | SchemaBase | Sequence[dict | SchemaBase]] = Undefined,
+        fill: Optional[dict] = Undefined,
+        fillOpacity: Optional[dict] = Undefined,
+        href: Optional[dict] = Undefined,
+        key: Optional[dict] = Undefined,
+        latitude: Optional[dict] = Undefined,
+        latitude2: Optional[dict] = Undefined,
+        longitude: Optional[dict] = Undefined,
+        longitude2: Optional[dict] = Undefined,
+        opacity: Optional[dict] = Undefined,
+        order: Optional[dict | SchemaBase | Sequence[dict | SchemaBase]] = Undefined,
+        radius: Optional[dict] = Undefined,
+        radius2: Optional[dict] = Undefined,
+        shape: Optional[dict] = Undefined,
+        size: Optional[dict] = Undefined,
+        stroke: Optional[dict] = Undefined,
+        strokeDash: Optional[dict] = Undefined,
+        strokeOpacity: Optional[dict] = Undefined,
+        strokeWidth: Optional[dict] = Undefined,
+        text: Optional[dict] = Undefined,
+        theta: Optional[dict] = Undefined,
+        theta2: Optional[dict] = Undefined,
+        tooltip: Optional[
+            dict | None | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        url: Optional[dict] = Undefined,
+        x: Optional[dict] = Undefined,
+        x2: Optional[dict] = Undefined,
+        xError: Optional[dict] = Undefined,
+        xError2: Optional[dict] = Undefined,
+        xOffset: Optional[dict] = Undefined,
+        y: Optional[dict] = Undefined,
+        y2: Optional[dict] = Undefined,
+        yError: Optional[dict] = Undefined,
+        yError2: Optional[dict] = Undefined,
+        yOffset: Optional[dict] = Undefined,
         **kwds,
     ):
-        super(SharedEncoding, self).__init__(
+        super().__init__(
             angle=angle,
             color=color,
             description=description,
@@ -38207,7 +21092,7 @@ class SingleDefUnitChannel(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SingleDefUnitChannel"}
 
     def __init__(self, *args):
-        super(SingleDefUnitChannel, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Sort(VegaLiteSchema):
@@ -38216,7 +21101,7 @@ class Sort(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Sort"}
 
     def __init__(self, *args, **kwds):
-        super(Sort, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class AllSortString(Sort):
@@ -38225,7 +21110,7 @@ class AllSortString(Sort):
     _schema = {"$ref": "#/definitions/AllSortString"}
 
     def __init__(self, *args, **kwds):
-        super(AllSortString, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class EncodingSortField(Sort):
@@ -38261,42 +21146,12 @@ class EncodingSortField(Sort):
 
     def __init__(
         self,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        op: Union[
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, "SchemaBase", Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        op: Optional[SchemaBase | NonArgAggregateOp_T] = Undefined,
+        order: Optional[None | SortOrder_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(EncodingSortField, self).__init__(field=field, op=op, order=order, **kwds)
+        super().__init__(field=field, op=op, order=order, **kwds)
 
 
 class SortArray(Sort):
@@ -38305,7 +21160,7 @@ class SortArray(Sort):
     _schema = {"$ref": "#/definitions/SortArray"}
 
     def __init__(self, *args, **kwds):
-        super(SortArray, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class SortByChannel(AllSortString):
@@ -38314,7 +21169,7 @@ class SortByChannel(AllSortString):
     _schema = {"$ref": "#/definitions/SortByChannel"}
 
     def __init__(self, *args):
-        super(SortByChannel, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SortByChannelDesc(AllSortString):
@@ -38323,7 +21178,7 @@ class SortByChannelDesc(AllSortString):
     _schema = {"$ref": "#/definitions/SortByChannelDesc"}
 
     def __init__(self, *args):
-        super(SortByChannelDesc, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SortByEncoding(Sort):
@@ -38345,30 +21200,11 @@ class SortByEncoding(Sort):
 
     def __init__(
         self,
-        encoding: Union[
-            "SchemaBase",
-            Literal[
-                "x",
-                "y",
-                "color",
-                "fill",
-                "stroke",
-                "strokeWidth",
-                "size",
-                "shape",
-                "fillOpacity",
-                "strokeOpacity",
-                "opacity",
-                "text",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        order: Union[
-            None, "SchemaBase", Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        encoding: Optional[SchemaBase | SortByChannel_T] = Undefined,
+        order: Optional[None | SortOrder_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(SortByEncoding, self).__init__(encoding=encoding, order=order, **kwds)
+        super().__init__(encoding=encoding, order=order, **kwds)
 
 
 class SortField(VegaLiteSchema):
@@ -38389,13 +21225,11 @@ class SortField(VegaLiteSchema):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        order: Union[
-            None, "SchemaBase", Literal["ascending", "descending"], UndefinedType
-        ] = Undefined,
+        field: Optional[str | SchemaBase] = Undefined,
+        order: Optional[None | SortOrder_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(SortField, self).__init__(field=field, order=order, **kwds)
+        super().__init__(field=field, order=order, **kwds)
 
 
 class SortOrder(AllSortString):
@@ -38404,7 +21238,7 @@ class SortOrder(AllSortString):
     _schema = {"$ref": "#/definitions/SortOrder"}
 
     def __init__(self, *args):
-        super(SortOrder, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Spec(VegaLiteSchema):
@@ -38415,7 +21249,7 @@ class Spec(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Spec"}
 
     def __init__(self, *args, **kwds):
-        super(Spec, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class ConcatSpecGenericSpec(Spec, NonNormalizedSpec):
@@ -38509,25 +21343,21 @@ class ConcatSpecGenericSpec(Spec, NonNormalizedSpec):
 
     def __init__(
         self,
-        concat: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        concat: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(ConcatSpecGenericSpec, self).__init__(
+        super().__init__(
             concat=concat,
             align=align,
             bounds=bounds,
@@ -38641,26 +21471,22 @@ class FacetSpec(Spec, NonNormalizedSpec):
 
     def __init__(
         self,
-        facet: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spec: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        facet: Optional[dict | SchemaBase] = Undefined,
+        spec: Optional[dict | SchemaBase] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(FacetSpec, self).__init__(
+        super().__init__(
             facet=facet,
             spec=spec,
             align=align,
@@ -38808,51 +21634,26 @@ class FacetedUnitSpec(Spec, NonNormalizedSpec):
 
     def __init__(
         self,
-        mark: Union[
-            str,
-            dict,
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "bar",
-                "image",
-                "line",
-                "point",
-                "rect",
-                "rule",
-                "text",
-                "tick",
-                "trail",
-                "circle",
-                "square",
-                "geoshape",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        height: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        view: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        width: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
+        mark: Optional[str | dict | Mark_T | SchemaBase] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        height: Optional[str | dict | float | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        view: Optional[dict | SchemaBase] = Undefined,
+        width: Optional[str | dict | float | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FacetedUnitSpec, self).__init__(
+        super().__init__(
             mark=mark,
             align=align,
             bounds=bounds,
@@ -38923,21 +21724,19 @@ class HConcatSpecGenericSpec(Spec, NonNormalizedSpec):
 
     def __init__(
         self,
-        hconcat: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        hconcat: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[float] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(HConcatSpecGenericSpec, self).__init__(
+        super().__init__(
             hconcat=hconcat,
             bounds=bounds,
             center=center,
@@ -39036,23 +21835,21 @@ class LayerSpec(Spec, NonNormalizedSpec):
 
     def __init__(
         self,
-        layer: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        height: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        view: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        width: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
+        layer: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        height: Optional[str | dict | float | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        view: Optional[dict | SchemaBase] = Undefined,
+        width: Optional[str | dict | float | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(LayerSpec, self).__init__(
+        super().__init__(
             layer=layer,
             data=data,
             description=description,
@@ -39075,7 +21872,7 @@ class RepeatSpec(Spec, NonNormalizedSpec):
     _schema = {"$ref": "#/definitions/RepeatSpec"}
 
     def __init__(self, *args, **kwds):
-        super(RepeatSpec, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LayerRepeatSpec(RepeatSpec):
@@ -39176,26 +21973,22 @@ class LayerRepeatSpec(RepeatSpec):
 
     def __init__(
         self,
-        repeat: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spec: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        repeat: Optional[dict | SchemaBase] = Undefined,
+        spec: Optional[dict | SchemaBase] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(LayerRepeatSpec, self).__init__(
+        super().__init__(
             repeat=repeat,
             spec=spec,
             align=align,
@@ -39312,26 +22105,22 @@ class NonLayerRepeatSpec(RepeatSpec):
 
     def __init__(
         self,
-        repeat: Union[dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        spec: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        repeat: Optional[dict | SchemaBase | Sequence[str]] = Undefined,
+        spec: Optional[dict | SchemaBase] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(NonLayerRepeatSpec, self).__init__(
+        super().__init__(
             repeat=repeat,
             spec=spec,
             align=align,
@@ -39365,11 +22154,11 @@ class SphereGenerator(Generator):
 
     def __init__(
         self,
-        sphere: Union[bool, dict, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        sphere: Optional[bool | dict] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(SphereGenerator, self).__init__(sphere=sphere, name=name, **kwds)
+        super().__init__(sphere=sphere, name=name, **kwds)
 
 
 class StackOffset(VegaLiteSchema):
@@ -39378,7 +22167,7 @@ class StackOffset(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/StackOffset"}
 
     def __init__(self, *args):
-        super(StackOffset, self).__init__(*args)
+        super().__init__(*args)
 
 
 class StandardType(VegaLiteSchema):
@@ -39387,7 +22176,7 @@ class StandardType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/StandardType"}
 
     def __init__(self, *args):
-        super(StandardType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Step(VegaLiteSchema):
@@ -39405,8 +22194,8 @@ class Step(VegaLiteSchema):
 
     _schema = {"$ref": "#/definitions/Step"}
 
-    def __init__(self, step: Union[float, UndefinedType] = Undefined, **kwds):
-        super(Step, self).__init__(step=step, **kwds)
+    def __init__(self, step: Optional[float] = Undefined, **kwds):
+        super().__init__(step=step, **kwds)
 
 
 class StepFor(VegaLiteSchema):
@@ -39415,7 +22204,7 @@ class StepFor(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/StepFor"}
 
     def __init__(self, *args):
-        super(StepFor, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Stream(VegaLiteSchema):
@@ -39424,7 +22213,7 @@ class Stream(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Stream"}
 
     def __init__(self, *args, **kwds):
-        super(Stream, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class DerivedStream(Stream):
@@ -39455,36 +22244,17 @@ class DerivedStream(Stream):
 
     def __init__(
         self,
-        stream: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        between: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        consume: Union[bool, UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        filter: Union[
-            str, "SchemaBase", Sequence[Union[str, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        markname: Union[str, UndefinedType] = Undefined,
-        marktype: Union[
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "image",
-                "group",
-                "line",
-                "path",
-                "rect",
-                "rule",
-                "shape",
-                "symbol",
-                "text",
-                "trail",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        throttle: Union[float, UndefinedType] = Undefined,
+        stream: Optional[dict | SchemaBase] = Undefined,
+        between: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        consume: Optional[bool] = Undefined,
+        debounce: Optional[float] = Undefined,
+        filter: Optional[str | SchemaBase | Sequence[str | SchemaBase]] = Undefined,
+        markname: Optional[str] = Undefined,
+        marktype: Optional[MarkType_T | SchemaBase] = Undefined,
+        throttle: Optional[float] = Undefined,
         **kwds,
     ):
-        super(DerivedStream, self).__init__(
+        super().__init__(
             stream=stream,
             between=between,
             consume=consume,
@@ -39503,7 +22273,7 @@ class EventStream(Stream):
     _schema = {"$ref": "#/definitions/EventStream"}
 
     def __init__(self, *args, **kwds):
-        super(EventStream, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class MergedStream(Stream):
@@ -39534,36 +22304,17 @@ class MergedStream(Stream):
 
     def __init__(
         self,
-        merge: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        between: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        consume: Union[bool, UndefinedType] = Undefined,
-        debounce: Union[float, UndefinedType] = Undefined,
-        filter: Union[
-            str, "SchemaBase", Sequence[Union[str, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        markname: Union[str, UndefinedType] = Undefined,
-        marktype: Union[
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "image",
-                "group",
-                "line",
-                "path",
-                "rect",
-                "rule",
-                "shape",
-                "symbol",
-                "text",
-                "trail",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        throttle: Union[float, UndefinedType] = Undefined,
+        merge: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        between: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        consume: Optional[bool] = Undefined,
+        debounce: Optional[float] = Undefined,
+        filter: Optional[str | SchemaBase | Sequence[str | SchemaBase]] = Undefined,
+        markname: Optional[str] = Undefined,
+        marktype: Optional[MarkType_T | SchemaBase] = Undefined,
+        throttle: Optional[float] = Undefined,
         **kwds,
     ):
-        super(MergedStream, self).__init__(
+        super().__init__(
             merge=merge,
             between=between,
             consume=consume,
@@ -39768,71 +22519,20 @@ class StringFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -39847,8 +22547,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -39863,80 +22563,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(StringFieldDef, self).__init__(
+        super().__init__(
             aggregate=aggregate,
             bandPosition=bandPosition,
             bin=bin,
@@ -40151,77 +22784,24 @@ class StringFieldDefWithCondition(VegaLiteSchema):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -40236,8 +22816,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -40252,80 +22832,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(StringFieldDefWithCondition, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -40359,17 +22872,13 @@ class StringValueDefWithCondition(VegaLiteSchema):
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(StringValueDefWithCondition, self).__init__(
-            condition=condition, value=value, **kwds
-        )
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class StrokeCap(VegaLiteSchema):
@@ -40378,7 +22887,7 @@ class StrokeCap(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/StrokeCap"}
 
     def __init__(self, *args):
-        super(StrokeCap, self).__init__(*args)
+        super().__init__(*args)
 
 
 class StrokeJoin(VegaLiteSchema):
@@ -40387,7 +22896,7 @@ class StrokeJoin(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/StrokeJoin"}
 
     def __init__(self, *args):
-        super(StrokeJoin, self).__init__(*args)
+        super().__init__(*args)
 
 
 class StyleConfigIndex(VegaLiteSchema):
@@ -40440,24 +22949,24 @@ class StyleConfigIndex(VegaLiteSchema):
 
     def __init__(
         self,
-        arc: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        area: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        bar: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        circle: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        geoshape: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        image: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        line: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        mark: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        point: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        rect: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        rule: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        square: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        text: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        tick: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        trail: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        arc: Optional[dict | SchemaBase] = Undefined,
+        area: Optional[dict | SchemaBase] = Undefined,
+        bar: Optional[dict | SchemaBase] = Undefined,
+        circle: Optional[dict | SchemaBase] = Undefined,
+        geoshape: Optional[dict | SchemaBase] = Undefined,
+        image: Optional[dict | SchemaBase] = Undefined,
+        line: Optional[dict | SchemaBase] = Undefined,
+        mark: Optional[dict | SchemaBase] = Undefined,
+        point: Optional[dict | SchemaBase] = Undefined,
+        rect: Optional[dict | SchemaBase] = Undefined,
+        rule: Optional[dict | SchemaBase] = Undefined,
+        square: Optional[dict | SchemaBase] = Undefined,
+        text: Optional[dict | SchemaBase] = Undefined,
+        tick: Optional[dict | SchemaBase] = Undefined,
+        trail: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(StyleConfigIndex, self).__init__(
+        super().__init__(
             arc=arc,
             area=area,
             bar=bar,
@@ -40483,7 +22992,7 @@ class SymbolShape(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/SymbolShape"}
 
     def __init__(self, *args):
-        super(SymbolShape, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Text(VegaLiteSchema):
@@ -40492,7 +23001,7 @@ class Text(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Text"}
 
     def __init__(self, *args, **kwds):
-        super(Text, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class TextBaseline(VegaLiteSchema):
@@ -40501,7 +23010,7 @@ class TextBaseline(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TextBaseline"}
 
     def __init__(self, *args, **kwds):
-        super(TextBaseline, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class Baseline(TextBaseline):
@@ -40510,7 +23019,7 @@ class Baseline(TextBaseline):
     _schema = {"$ref": "#/definitions/Baseline"}
 
     def __init__(self, *args):
-        super(Baseline, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TextDef(VegaLiteSchema):
@@ -40519,7 +23028,7 @@ class TextDef(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TextDef"}
 
     def __init__(self, *args, **kwds):
-        super(TextDef, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class FieldOrDatumDefWithConditionStringDatumDefText(TextDef):
@@ -40672,24 +23181,20 @@ class FieldOrDatumDefWithConditionStringDatumDefText(TextDef):
 
     def __init__(
         self,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        datum: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
+        bandPosition: Optional[float] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal", "geojson"],
-            UndefinedType,
+        datum: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
         ] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[Type_T | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionStringDatumDefText, self).__init__(
+        super().__init__(
             bandPosition=bandPosition,
             condition=condition,
             datum=datum,
@@ -40904,77 +23409,24 @@ class FieldOrDatumDefWithConditionStringFieldDefText(TextDef):
 
     def __init__(
         self,
-        shorthand: Union[
-            str, dict, "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        format: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        formatType: Union[str, UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        shorthand: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        format: Optional[str | dict | SchemaBase] = Undefined,
+        formatType: Optional[str] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -40989,8 +23441,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -41005,80 +23457,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(FieldOrDatumDefWithConditionStringFieldDefText, self).__init__(
+        super().__init__(
             shorthand=shorthand,
             aggregate=aggregate,
             bandPosition=bandPosition,
@@ -41100,7 +23485,7 @@ class TextDirection(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TextDirection"}
 
     def __init__(self, *args):
-        super(TextDirection, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TickConfig(AnyMarkConfig):
@@ -41478,773 +23863,100 @@ class TickConfig(AnyMarkConfig):
 
     def __init__(
         self,
-        align: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ariaRole: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        blend: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, "_Parameter", "SchemaBase", Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        ellipsis: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        endAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        href: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        innerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineBreak: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            "SchemaBase", Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        shape: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        size: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        smooth: Union[
-            bool, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        startAngle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        tension: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str, bool, dict, None, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        url: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        width: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        endAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        startAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TickConfig, self).__init__(
+        super().__init__(
             align=align,
             angle=angle,
             aria=aria,
@@ -42326,7 +24038,7 @@ class TickCount(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TickCount"}
 
     def __init__(self, *args, **kwds):
-        super(TickCount, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class TimeInterval(TickCount):
@@ -42335,7 +24047,7 @@ class TimeInterval(TickCount):
     _schema = {"$ref": "#/definitions/TimeInterval"}
 
     def __init__(self, *args):
-        super(TimeInterval, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TimeIntervalStep(TickCount):
@@ -42354,24 +24066,11 @@ class TimeIntervalStep(TickCount):
 
     def __init__(
         self,
-        interval: Union[
-            "SchemaBase",
-            Literal[
-                "millisecond",
-                "second",
-                "minute",
-                "hour",
-                "day",
-                "week",
-                "month",
-                "year",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
+        interval: Optional[SchemaBase | TimeInterval_T] = Undefined,
+        step: Optional[float] = Undefined,
         **kwds,
     ):
-        super(TimeIntervalStep, self).__init__(interval=interval, step=step, **kwds)
+        super().__init__(interval=interval, step=step, **kwds)
 
 
 class TimeLocale(VegaLiteSchema):
@@ -42403,17 +24102,17 @@ class TimeLocale(VegaLiteSchema):
 
     def __init__(
         self,
-        date: Union[str, UndefinedType] = Undefined,
-        dateTime: Union[str, UndefinedType] = Undefined,
-        days: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        months: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        periods: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        shortDays: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        shortMonths: Union["SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        time: Union[str, UndefinedType] = Undefined,
+        date: Optional[str] = Undefined,
+        dateTime: Optional[str] = Undefined,
+        days: Optional[SchemaBase | Sequence[str]] = Undefined,
+        months: Optional[SchemaBase | Sequence[str]] = Undefined,
+        periods: Optional[SchemaBase | Sequence[str]] = Undefined,
+        shortDays: Optional[SchemaBase | Sequence[str]] = Undefined,
+        shortMonths: Optional[SchemaBase | Sequence[str]] = Undefined,
+        time: Optional[str] = Undefined,
         **kwds,
     ):
-        super(TimeLocale, self).__init__(
+        super().__init__(
             date=date,
             dateTime=dateTime,
             days=days,
@@ -42432,7 +24131,7 @@ class TimeUnit(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TimeUnit"}
 
     def __init__(self, *args, **kwds):
-        super(TimeUnit, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class MultiTimeUnit(TimeUnit):
@@ -42441,7 +24140,7 @@ class MultiTimeUnit(TimeUnit):
     _schema = {"$ref": "#/definitions/MultiTimeUnit"}
 
     def __init__(self, *args, **kwds):
-        super(MultiTimeUnit, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LocalMultiTimeUnit(MultiTimeUnit):
@@ -42450,7 +24149,7 @@ class LocalMultiTimeUnit(MultiTimeUnit):
     _schema = {"$ref": "#/definitions/LocalMultiTimeUnit"}
 
     def __init__(self, *args):
-        super(LocalMultiTimeUnit, self).__init__(*args)
+        super().__init__(*args)
 
 
 class SingleTimeUnit(TimeUnit):
@@ -42459,7 +24158,7 @@ class SingleTimeUnit(TimeUnit):
     _schema = {"$ref": "#/definitions/SingleTimeUnit"}
 
     def __init__(self, *args, **kwds):
-        super(SingleTimeUnit, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class LocalSingleTimeUnit(SingleTimeUnit):
@@ -42468,7 +24167,7 @@ class LocalSingleTimeUnit(SingleTimeUnit):
     _schema = {"$ref": "#/definitions/LocalSingleTimeUnit"}
 
     def __init__(self, *args):
-        super(LocalSingleTimeUnit, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TimeUnitParams(VegaLiteSchema):
@@ -42497,105 +24196,20 @@ class TimeUnitParams(VegaLiteSchema):
 
     def __init__(
         self,
-        binned: Union[bool, UndefinedType] = Undefined,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
+        binned: Optional[bool] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(TimeUnitParams, self).__init__(
+        super().__init__(
             binned=binned, maxbins=maxbins, step=step, unit=unit, utc=utc, **kwds
         )
 
@@ -42620,106 +24234,19 @@ class TimeUnitTransformParams(VegaLiteSchema):
 
     def __init__(
         self,
-        maxbins: Union[float, UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        unit: Union[
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        utc: Union[bool, UndefinedType] = Undefined,
+        maxbins: Optional[float] = Undefined,
+        step: Optional[float] = Undefined,
+        unit: Optional[
+            SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+        ] = Undefined,
+        utc: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(TimeUnitTransformParams, self).__init__(
-            maxbins=maxbins, step=step, unit=unit, utc=utc, **kwds
-        )
+        super().__init__(maxbins=maxbins, step=step, unit=unit, utc=utc, **kwds)
 
 
 class TitleAnchor(VegaLiteSchema):
@@ -42728,7 +24255,7 @@ class TitleAnchor(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TitleAnchor"}
 
     def __init__(self, *args):
-        super(TitleAnchor, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TitleConfig(VegaLiteSchema):
@@ -42816,435 +24343,40 @@ class TitleConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        align: Union[
-            "SchemaBase", Literal["left", "center", "right"], UndefinedType
-        ] = Undefined,
-        anchor: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[None, "start", "middle", "end"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        baseline: Union[
-            str, "SchemaBase", Literal["top", "middle", "bottom"], UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        frame: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["bounds", "group"],
-            UndefinedType,
-        ] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["none", "left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        subtitleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        subtitleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        subtitleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        zindex: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        align: Optional[Align_T | SchemaBase] = Undefined,
+        anchor: Optional[dict | Parameter | SchemaBase | TitleAnchor_T] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[str | Baseline_T | SchemaBase] = Undefined,
+        color: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        frame: Optional[str | dict | Parameter | SchemaBase | TitleFrame_T] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | TitleOrient_T] = Undefined,
+        subtitleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        subtitleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        subtitleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        subtitleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        subtitleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        subtitleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        subtitlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        zindex: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TitleConfig, self).__init__(
+        super().__init__(
             align=align,
             anchor=anchor,
             angle=angle,
@@ -43280,7 +24412,7 @@ class TitleFrame(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TitleFrame"}
 
     def __init__(self, *args):
-        super(TitleFrame, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TitleOrient(VegaLiteSchema):
@@ -43289,7 +24421,7 @@ class TitleOrient(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TitleOrient"}
 
     def __init__(self, *args):
-        super(TitleOrient, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TitleParams(VegaLiteSchema):
@@ -43397,434 +24529,43 @@ class TitleParams(VegaLiteSchema):
 
     def __init__(
         self,
-        text: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
-        ] = Undefined,
-        align: Union[
-            "SchemaBase", Literal["left", "center", "right"], UndefinedType
-        ] = Undefined,
-        anchor: Union[
-            "SchemaBase", Literal[None, "start", "middle", "end"], UndefinedType
-        ] = Undefined,
-        angle: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        aria: Union[bool, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        baseline: Union[
-            str, "SchemaBase", Literal["top", "middle", "bottom"], UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        dx: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        dy: Union[dict, float, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        font: Union[str, dict, "_Parameter", "SchemaBase", UndefinedType] = Undefined,
-        fontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        frame: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["bounds", "group"],
-            UndefinedType,
-        ] = Undefined,
-        limit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        offset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        orient: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["none", "left", "right", "top", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        subtitle: Union[str, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        subtitleColor: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        subtitleFont: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontSize: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontStyle: Union[
-            str, dict, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitleFontWeight: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        subtitleLineHeight: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        subtitlePadding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        zindex: Union[float, UndefinedType] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        align: Optional[Align_T | SchemaBase] = Undefined,
+        anchor: Optional[SchemaBase | TitleAnchor_T] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        baseline: Optional[str | Baseline_T | SchemaBase] = Undefined,
+        color: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        frame: Optional[str | dict | Parameter | SchemaBase | TitleFrame_T] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        orient: Optional[dict | Parameter | SchemaBase | TitleOrient_T] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        subtitle: Optional[str | SchemaBase | Sequence[str]] = Undefined,
+        subtitleColor: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        subtitleFont: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        subtitleFontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        subtitleFontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        subtitleFontWeight: Optional[
+            dict | Parameter | SchemaBase | FontWeight_T
+        ] = Undefined,
+        subtitleLineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        subtitlePadding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        zindex: Optional[float] = Undefined,
         **kwds,
     ):
-        super(TitleParams, self).__init__(
+        super().__init__(
             text=text,
             align=align,
             anchor=anchor,
@@ -43870,11 +24611,9 @@ class TooltipContent(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TooltipContent"}
 
     def __init__(
-        self,
-        content: Union[Literal["encoding", "data"], UndefinedType] = Undefined,
-        **kwds,
+        self, content: Optional[Literal["encoding", "data"]] = Undefined, **kwds
     ):
-        super(TooltipContent, self).__init__(content=content, **kwds)
+        super().__init__(content=content, **kwds)
 
 
 class TopLevelParameter(VegaLiteSchema):
@@ -43883,7 +24622,7 @@ class TopLevelParameter(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TopLevelParameter"}
 
     def __init__(self, *args, **kwds):
-        super(TopLevelParameter, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class TopLevelSelectionParameter(TopLevelParameter):
@@ -43938,25 +24677,16 @@ class TopLevelSelectionParameter(TopLevelParameter):
 
     def __init__(
         self,
-        name: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        select: Union[
-            dict, "SchemaBase", Literal["point", "interval"], UndefinedType
-        ] = Undefined,
-        bind: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            "SchemaBase",
-            Sequence[Union[dict, "SchemaBase"]],
-            UndefinedType,
-        ] = Undefined,
-        views: Union[Sequence[str], UndefinedType] = Undefined,
+        name: Optional[str | SchemaBase] = Undefined,
+        select: Optional[dict | SchemaBase | SelectionType_T] = Undefined,
+        bind: Optional[str | dict | SchemaBase] = Undefined,
+        value: Optional[
+            str | bool | dict | None | float | SchemaBase | Sequence[dict | SchemaBase]
+        ] = Undefined,
+        views: Optional[Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(TopLevelSelectionParameter, self).__init__(
+        super().__init__(
             name=name, select=select, bind=bind, value=value, views=views, **kwds
         )
 
@@ -43970,7 +24700,7 @@ class TopLevelSpec(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TopLevelSpec"}
 
     def __init__(self, *args, **kwds):
-        super(TopLevelSpec, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class TopLevelConcatSpec(TopLevelSpec):
@@ -44098,195 +24828,30 @@ class TopLevelConcatSpec(TopLevelSpec):
 
     def __init__(
         self,
-        concat: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        config: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        datasets: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        usermeta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        concat: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        config: Optional[dict | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        datasets: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        usermeta: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TopLevelConcatSpec, self).__init__(
+        super().__init__(
             concat=concat,
             align=align,
             autosize=autosize,
@@ -44441,196 +25006,31 @@ class TopLevelFacetSpec(TopLevelSpec):
 
     def __init__(
         self,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        facet: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spec: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        columns: Union[float, UndefinedType] = Undefined,
-        config: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        datasets: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        usermeta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        facet: Optional[dict | SchemaBase] = Undefined,
+        spec: Optional[dict | SchemaBase] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        columns: Optional[float] = Undefined,
+        config: Optional[dict | SchemaBase] = Undefined,
+        datasets: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        usermeta: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TopLevelFacetSpec, self).__init__(
+        super().__init__(
             data=data,
             facet=facet,
             spec=spec,
@@ -44738,191 +25138,28 @@ class TopLevelHConcatSpec(TopLevelSpec):
 
     def __init__(
         self,
-        hconcat: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        config: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        datasets: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        usermeta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        hconcat: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool] = Undefined,
+        config: Optional[dict | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        datasets: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[float] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        usermeta: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TopLevelHConcatSpec, self).__init__(
+        super().__init__(
             hconcat=hconcat,
             autosize=autosize,
             background=background,
@@ -45061,193 +25298,30 @@ class TopLevelLayerSpec(TopLevelSpec):
 
     def __init__(
         self,
-        layer: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        config: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        datasets: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        height: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        usermeta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        view: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        width: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
+        layer: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        config: Optional[dict | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        datasets: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        height: Optional[str | dict | float | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        usermeta: Optional[dict | SchemaBase] = Undefined,
+        view: Optional[dict | SchemaBase] = Undefined,
+        width: Optional[str | dict | float | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TopLevelLayerSpec, self).__init__(
+        super().__init__(
             layer=layer,
             autosize=autosize,
             background=background,
@@ -45277,7 +25351,7 @@ class TopLevelRepeatSpec(TopLevelSpec):
     _schema = {"$ref": "#/definitions/TopLevelRepeatSpec"}
 
     def __init__(self, *args, **kwds):
-        super(TopLevelRepeatSpec, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class TopLevelUnitSpec(TopLevelSpec):
@@ -45441,220 +25515,34 @@ class TopLevelUnitSpec(TopLevelSpec):
 
     def __init__(
         self,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        mark: Union[
-            str,
-            dict,
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "bar",
-                "image",
-                "line",
-                "point",
-                "rect",
-                "rule",
-                "text",
-                "tick",
-                "trail",
-                "circle",
-                "square",
-                "geoshape",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        align: Union[
-            dict, "SchemaBase", Literal["all", "each", "none"], UndefinedType
-        ] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        config: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        datasets: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        height: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[dict, float, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        usermeta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        view: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        width: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        mark: Optional[str | dict | Mark_T | SchemaBase] = Undefined,
+        align: Optional[dict | SchemaBase | LayoutAlign_T] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool | dict | SchemaBase] = Undefined,
+        config: Optional[dict | SchemaBase] = Undefined,
+        datasets: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        height: Optional[str | dict | float | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[dict | float | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        usermeta: Optional[dict | SchemaBase] = Undefined,
+        view: Optional[dict | SchemaBase] = Undefined,
+        width: Optional[str | dict | float | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TopLevelUnitSpec, self).__init__(
+        super().__init__(
             data=data,
             mark=mark,
             align=align,
@@ -45765,191 +25653,28 @@ class TopLevelVConcatSpec(TopLevelSpec):
 
     def __init__(
         self,
-        vconcat: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        autosize: Union[
-            dict,
-            "SchemaBase",
-            Literal["pad", "none", "fit", "fit-x", "fit-y"],
-            UndefinedType,
-        ] = Undefined,
-        background: Union[
-            str,
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        config: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        datasets: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        padding: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        usermeta: Union[dict, "SchemaBase", UndefinedType] = Undefined,
+        vconcat: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        autosize: Optional[dict | SchemaBase | AutosizeType_T] = Undefined,
+        background: Optional[
+            str | dict | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool] = Undefined,
+        config: Optional[dict | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        datasets: Optional[dict | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        padding: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[float] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        usermeta: Optional[dict | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(TopLevelVConcatSpec, self).__init__(
+        super().__init__(
             vconcat=vconcat,
             autosize=autosize,
             background=background,
@@ -46016,15 +25741,13 @@ class TopoDataFormat(DataFormat):
 
     def __init__(
         self,
-        feature: Union[str, UndefinedType] = Undefined,
-        mesh: Union[str, UndefinedType] = Undefined,
-        parse: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        type: Union[str, UndefinedType] = Undefined,
+        feature: Optional[str] = Undefined,
+        mesh: Optional[str] = Undefined,
+        parse: Optional[dict | None | SchemaBase] = Undefined,
+        type: Optional[str] = Undefined,
         **kwds,
     ):
-        super(TopoDataFormat, self).__init__(
-            feature=feature, mesh=mesh, parse=parse, type=type, **kwds
-        )
+        super().__init__(feature=feature, mesh=mesh, parse=parse, type=type, **kwds)
 
 
 class Transform(VegaLiteSchema):
@@ -46033,7 +25756,7 @@ class Transform(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Transform"}
 
     def __init__(self, *args, **kwds):
-        super(Transform, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class AggregateTransform(Transform):
@@ -46053,15 +25776,11 @@ class AggregateTransform(Transform):
 
     def __init__(
         self,
-        aggregate: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
+        aggregate: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(AggregateTransform, self).__init__(
-            aggregate=aggregate, groupby=groupby, **kwds
-        )
+        super().__init__(aggregate=aggregate, groupby=groupby, **kwds)
 
 
 class BinTransform(Transform):
@@ -46086,11 +25805,11 @@ class BinTransform(Transform):
 
     def __init__(
         self,
-        bin: Union[bool, dict, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
+        bin: Optional[bool | dict | SchemaBase] = Undefined,
+        field: Optional[str | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(BinTransform, self).__init__(bin=bin, field=field, **kwds)
+        super().__init__(bin=bin, field=field, **kwds)
 
 
 class CalculateTransform(Transform):
@@ -46108,8 +25827,8 @@ class CalculateTransform(Transform):
 
     _schema = {"$ref": "#/definitions/CalculateTransform"}
 
-    def __init__(self, calculate: Union[str, UndefinedType] = Undefined, **kwds):
-        super(CalculateTransform, self).__init__(calculate=calculate, **kwds)
+    def __init__(self, calculate: Optional[str] = Undefined, **kwds):
+        super().__init__(calculate=calculate, **kwds)
 
 
 class DensityTransform(Transform):
@@ -46123,7 +25842,7 @@ class DensityTransform(Transform):
     bandwidth : float
         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.
+        Scott's rule.
     counts : bool
         A boolean flag indicating if the output values should be probability estimates
         (false) or smoothed counts (true).
@@ -46166,18 +25885,18 @@ class DensityTransform(Transform):
 
     def __init__(
         self,
-        density: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        bandwidth: Union[float, UndefinedType] = Undefined,
-        counts: Union[bool, UndefinedType] = Undefined,
-        cumulative: Union[bool, UndefinedType] = Undefined,
-        extent: Union[Sequence[float], UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        maxsteps: Union[float, UndefinedType] = Undefined,
-        minsteps: Union[float, UndefinedType] = Undefined,
-        steps: Union[float, UndefinedType] = Undefined,
+        density: Optional[str | SchemaBase] = Undefined,
+        bandwidth: Optional[float] = Undefined,
+        counts: Optional[bool] = Undefined,
+        cumulative: Optional[bool] = Undefined,
+        extent: Optional[Sequence[float]] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        maxsteps: Optional[float] = Undefined,
+        minsteps: Optional[float] = Undefined,
+        steps: Optional[float] = Undefined,
         **kwds,
     ):
-        super(DensityTransform, self).__init__(
+        super().__init__(
             density=density,
             bandwidth=bandwidth,
             counts=counts,
@@ -46207,11 +25926,11 @@ class ExtentTransform(Transform):
 
     def __init__(
         self,
-        extent: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        param: Union[str, "SchemaBase", UndefinedType] = Undefined,
+        extent: Optional[str | SchemaBase] = Undefined,
+        param: Optional[str | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ExtentTransform, self).__init__(extent=extent, param=param, **kwds)
+        super().__init__(extent=extent, param=param, **kwds)
 
 
 class FilterTransform(Transform):
@@ -46252,10 +25971,8 @@ class FilterTransform(Transform):
 
     _schema = {"$ref": "#/definitions/FilterTransform"}
 
-    def __init__(
-        self, filter: Union[str, dict, "SchemaBase", UndefinedType] = Undefined, **kwds
-    ):
-        super(FilterTransform, self).__init__(filter=filter, **kwds)
+    def __init__(self, filter: Optional[str | dict | SchemaBase] = Undefined, **kwds):
+        super().__init__(filter=filter, **kwds)
 
 
 class FlattenTransform(Transform):
@@ -46278,11 +25995,9 @@ class FlattenTransform(Transform):
     _schema = {"$ref": "#/definitions/FlattenTransform"}
 
     def __init__(
-        self,
-        flatten: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        **kwds,
+        self, flatten: Optional[Sequence[str | SchemaBase]] = Undefined, **kwds
     ):
-        super(FlattenTransform, self).__init__(flatten=flatten, **kwds)
+        super().__init__(flatten=flatten, **kwds)
 
 
 class FoldTransform(Transform):
@@ -46300,12 +26015,8 @@ class FoldTransform(Transform):
 
     _schema = {"$ref": "#/definitions/FoldTransform"}
 
-    def __init__(
-        self,
-        fold: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        **kwds,
-    ):
-        super(FoldTransform, self).__init__(fold=fold, **kwds)
+    def __init__(self, fold: Optional[Sequence[str | SchemaBase]] = Undefined, **kwds):
+        super().__init__(fold=fold, **kwds)
 
 
 class ImputeTransform(Transform):
@@ -46356,20 +26067,16 @@ class ImputeTransform(Transform):
 
     def __init__(
         self,
-        impute: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        key: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        keyvals: Union[dict, "SchemaBase", Sequence[Any], UndefinedType] = Undefined,
-        method: Union[
-            "SchemaBase",
-            Literal["value", "median", "max", "min", "mean"],
-            UndefinedType,
-        ] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        impute: Optional[str | SchemaBase] = Undefined,
+        key: Optional[str | SchemaBase] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        keyvals: Optional[dict | SchemaBase | Sequence[Any]] = Undefined,
+        method: Optional[SchemaBase | ImputeMethod_T] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
     ):
-        super(ImputeTransform, self).__init__(
+        super().__init__(
             impute=impute,
             key=key,
             frame=frame,
@@ -46398,15 +26105,11 @@ class JoinAggregateTransform(Transform):
 
     def __init__(
         self,
-        joinaggregate: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
+        joinaggregate: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(JoinAggregateTransform, self).__init__(
-            joinaggregate=joinaggregate, groupby=groupby, **kwds
-        )
+        super().__init__(joinaggregate=joinaggregate, groupby=groupby, **kwds)
 
 
 class LoessTransform(Transform):
@@ -46437,13 +26140,13 @@ class LoessTransform(Transform):
 
     def __init__(
         self,
-        loess: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        on: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        bandwidth: Union[float, UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
+        loess: Optional[str | SchemaBase] = Undefined,
+        on: Optional[str | SchemaBase] = Undefined,
+        bandwidth: Optional[float] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(LoessTransform, self).__init__(
+        super().__init__(
             loess=loess, on=on, bandwidth=bandwidth, groupby=groupby, **kwds
         )
 
@@ -46478,11 +26181,11 @@ class LookupTransform(Transform):
 
     def __init__(
         self,
-        lookup: Union[str, UndefinedType] = Undefined,
-        default: Union[Any, UndefinedType] = Undefined,
+        lookup: Optional[str] = Undefined,
+        default: Optional[Any] = Undefined,
         **kwds,
     ):
-        super(LookupTransform, self).__init__(lookup=lookup, default=default, **kwds)
+        super().__init__(lookup=lookup, default=default, **kwds)
 
 
 class PivotTransform(Transform):
@@ -46513,44 +26216,14 @@ class PivotTransform(Transform):
 
     def __init__(
         self,
-        pivot: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        limit: Union[float, UndefinedType] = Undefined,
-        op: Union[
-            "SchemaBase",
-            Literal[
-                "argmax",
-                "argmin",
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
+        pivot: Optional[str | SchemaBase] = Undefined,
+        value: Optional[str | SchemaBase] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        limit: Optional[float] = Undefined,
+        op: Optional[SchemaBase | AggregateOp_T] = Undefined,
         **kwds,
     ):
-        super(PivotTransform, self).__init__(
+        super().__init__(
             pivot=pivot, value=value, groupby=groupby, limit=limit, op=op, **kwds
         )
 
@@ -46583,13 +26256,13 @@ class QuantileTransform(Transform):
 
     def __init__(
         self,
-        quantile: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        probs: Union[Sequence[float], UndefinedType] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
+        quantile: Optional[str | SchemaBase] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        probs: Optional[Sequence[float]] = Undefined,
+        step: Optional[float] = Undefined,
         **kwds,
     ):
-        super(QuantileTransform, self).__init__(
+        super().__init__(
             quantile=quantile, groupby=groupby, probs=probs, step=step, **kwds
         )
 
@@ -46638,18 +26311,18 @@ class RegressionTransform(Transform):
 
     def __init__(
         self,
-        on: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        regression: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        extent: Union[Sequence[float], UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        method: Union[
-            Literal["linear", "log", "exp", "pow", "quad", "poly"], UndefinedType
-        ] = Undefined,
-        order: Union[float, UndefinedType] = Undefined,
-        params: Union[bool, UndefinedType] = Undefined,
+        on: Optional[str | SchemaBase] = Undefined,
+        regression: Optional[str | SchemaBase] = Undefined,
+        extent: Optional[Sequence[float]] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        method: Optional[
+            Literal["linear", "log", "exp", "pow", "quad", "poly"]
+        ] = Undefined,
+        order: Optional[float] = Undefined,
+        params: Optional[bool] = Undefined,
         **kwds,
     ):
-        super(RegressionTransform, self).__init__(
+        super().__init__(
             on=on,
             regression=regression,
             extent=extent,
@@ -46675,8 +26348,8 @@ class SampleTransform(Transform):
 
     _schema = {"$ref": "#/definitions/SampleTransform"}
 
-    def __init__(self, sample: Union[float, UndefinedType] = Undefined, **kwds):
-        super(SampleTransform, self).__init__(sample=sample, **kwds)
+    def __init__(self, sample: Optional[float] = Undefined, **kwds):
+        super().__init__(sample=sample, **kwds)
 
 
 class StackTransform(Transform):
@@ -46709,17 +26382,13 @@ class StackTransform(Transform):
 
     def __init__(
         self,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        stack: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        offset: Union[
-            Literal["zero", "center", "normalize"], UndefinedType
-        ] = Undefined,
-        sort: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        stack: Optional[str | SchemaBase] = Undefined,
+        offset: Optional[StackOffset_T] = Undefined,
+        sort: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(StackTransform, self).__init__(
-            groupby=groupby, stack=stack, offset=offset, sort=sort, **kwds
-        )
+        super().__init__(groupby=groupby, stack=stack, offset=offset, sort=sort, **kwds)
 
 
 class TimeUnitTransform(Transform):
@@ -46740,103 +26409,18 @@ class TimeUnitTransform(Transform):
 
     def __init__(
         self,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
+        field: Optional[str | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
         ] = Undefined,
         **kwds,
     ):
-        super(TimeUnitTransform, self).__init__(field=field, timeUnit=timeUnit, **kwds)
+        super().__init__(field=field, timeUnit=timeUnit, **kwds)
 
 
 class Type(VegaLiteSchema):
@@ -46847,7 +26431,7 @@ class Type(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Type"}
 
     def __init__(self, *args):
-        super(Type, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TypeForShape(VegaLiteSchema):
@@ -46856,7 +26440,7 @@ class TypeForShape(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/TypeForShape"}
 
     def __init__(self, *args):
-        super(TypeForShape, self).__init__(*args)
+        super().__init__(*args)
 
 
 class TypedFieldDef(VegaLiteSchema):
@@ -47018,69 +26602,18 @@ class TypedFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        aggregate: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        bandPosition: Union[float, UndefinedType] = Undefined,
-        bin: Union[str, bool, dict, None, "SchemaBase", UndefinedType] = Undefined,
-        field: Union[str, dict, "SchemaBase", UndefinedType] = Undefined,
-        timeUnit: Union[
-            dict,
-            "SchemaBase",
-            Literal[
-                "year",
-                "quarter",
-                "month",
-                "week",
-                "day",
-                "dayofyear",
-                "date",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds",
-            ],
-            Literal[
-                "utcyear",
-                "utcquarter",
-                "utcmonth",
-                "utcweek",
-                "utcday",
-                "utcdayofyear",
-                "utcdate",
-                "utchours",
-                "utcminutes",
-                "utcseconds",
-                "utcmilliseconds",
-            ],
-            Literal[
+        aggregate: Optional[dict | SchemaBase | NonArgAggregateOp_T] = Undefined,
+        bandPosition: Optional[float] = Undefined,
+        bin: Optional[str | bool | dict | None | SchemaBase] = Undefined,
+        field: Optional[str | dict | SchemaBase] = Undefined,
+        timeUnit: Optional[
+            dict
+            | SchemaBase
+            | UtcMultiTimeUnit_T
+            | UtcSingleTimeUnit_T
+            | LocalMultiTimeUnit_T
+            | LocalSingleTimeUnit_T
+            | Literal[
                 "binnedyear",
                 "binnedyearquarter",
                 "binnedyearquartermonth",
@@ -47095,8 +26628,8 @@ def __init__(
                 "binnedyearweekdayhoursminutes",
                 "binnedyearweekdayhoursminutesseconds",
                 "binnedyeardayofyear",
-            ],
-            Literal[
+            ]
+            | Literal[
                 "binnedutcyear",
                 "binnedutcyearquarter",
                 "binnedutcyearquartermonth",
@@ -47111,80 +26644,13 @@ def __init__(
                 "binnedutcyearweekdayhoursminutes",
                 "binnedutcyearweekdayhoursminutesseconds",
                 "binnedutcyeardayofyear",
-            ],
-            Literal[
-                "yearquarter",
-                "yearquartermonth",
-                "yearmonth",
-                "yearmonthdate",
-                "yearmonthdatehours",
-                "yearmonthdatehoursminutes",
-                "yearmonthdatehoursminutesseconds",
-                "yearweek",
-                "yearweekday",
-                "yearweekdayhours",
-                "yearweekdayhoursminutes",
-                "yearweekdayhoursminutesseconds",
-                "yeardayofyear",
-                "quartermonth",
-                "monthdate",
-                "monthdatehours",
-                "monthdatehoursminutes",
-                "monthdatehoursminutesseconds",
-                "weekday",
-                "weekdayhours",
-                "weekdayhoursminutes",
-                "weekdayhoursminutesseconds",
-                "dayhours",
-                "dayhoursminutes",
-                "dayhoursminutesseconds",
-                "hoursminutes",
-                "hoursminutesseconds",
-                "minutesseconds",
-                "secondsmilliseconds",
-            ],
-            Literal[
-                "utcyearquarter",
-                "utcyearquartermonth",
-                "utcyearmonth",
-                "utcyearmonthdate",
-                "utcyearmonthdatehours",
-                "utcyearmonthdatehoursminutes",
-                "utcyearmonthdatehoursminutesseconds",
-                "utcyearweek",
-                "utcyearweekday",
-                "utcyearweekdayhours",
-                "utcyearweekdayhoursminutes",
-                "utcyearweekdayhoursminutesseconds",
-                "utcyeardayofyear",
-                "utcquartermonth",
-                "utcmonthdate",
-                "utcmonthdatehours",
-                "utcmonthdatehoursminutes",
-                "utcmonthdatehoursminutesseconds",
-                "utcweekday",
-                "utcweeksdayhours",
-                "utcweekdayhoursminutes",
-                "utcweekdayhoursminutesseconds",
-                "utcdayhours",
-                "utcdayhoursminutes",
-                "utcdayhoursminutesseconds",
-                "utchoursminutes",
-                "utchoursminutesseconds",
-                "utcminutesseconds",
-                "utcsecondsmilliseconds",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        title: Union[str, None, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        type: Union[
-            "SchemaBase",
-            Literal["quantitative", "ordinal", "temporal", "nominal"],
-            UndefinedType,
+            ]
         ] = Undefined,
+        title: Optional[str | None | SchemaBase | Sequence[str]] = Undefined,
+        type: Optional[SchemaBase | StandardType_T] = Undefined,
         **kwds,
     ):
-        super(TypedFieldDef, self).__init__(
+        super().__init__(
             aggregate=aggregate,
             bandPosition=bandPosition,
             bin=bin,
@@ -47202,7 +26668,7 @@ class URI(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/URI"}
 
     def __init__(self, *args):
-        super(URI, self).__init__(*args)
+        super().__init__(*args)
 
 
 class UnitSpec(VegaLiteSchema):
@@ -47243,41 +26709,18 @@ class UnitSpec(VegaLiteSchema):
 
     def __init__(
         self,
-        mark: Union[
-            str,
-            dict,
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "bar",
-                "image",
-                "line",
-                "point",
-                "rect",
-                "rule",
-                "text",
-                "tick",
-                "trail",
-                "circle",
-                "square",
-                "geoshape",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        mark: Optional[str | dict | Mark_T | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(UnitSpec, self).__init__(
+        super().__init__(
             mark=mark,
             data=data,
             description=description,
@@ -47372,44 +26815,21 @@ class UnitSpecWithFrame(VegaLiteSchema):
 
     def __init__(
         self,
-        mark: Union[
-            str,
-            dict,
-            "SchemaBase",
-            Literal[
-                "arc",
-                "area",
-                "bar",
-                "image",
-                "line",
-                "point",
-                "rect",
-                "rule",
-                "text",
-                "tick",
-                "trail",
-                "circle",
-                "square",
-                "geoshape",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        encoding: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        height: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        params: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        projection: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        view: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        width: Union[str, dict, float, "SchemaBase", UndefinedType] = Undefined,
+        mark: Optional[str | dict | Mark_T | SchemaBase] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        encoding: Optional[dict | SchemaBase] = Undefined,
+        height: Optional[str | dict | float | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
+        params: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        projection: Optional[dict | SchemaBase] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        view: Optional[dict | SchemaBase] = Undefined,
+        width: Optional[str | dict | float | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(UnitSpecWithFrame, self).__init__(
+        super().__init__(
             mark=mark,
             data=data,
             description=description,
@@ -47445,12 +26865,12 @@ class UrlData(DataSource):
 
     def __init__(
         self,
-        url: Union[str, UndefinedType] = Undefined,
-        format: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
+        url: Optional[str] = Undefined,
+        format: Optional[dict | SchemaBase] = Undefined,
+        name: Optional[str] = Undefined,
         **kwds,
     ):
-        super(UrlData, self).__init__(url=url, format=format, name=name, **kwds)
+        super().__init__(url=url, format=format, name=name, **kwds)
 
 
 class UtcMultiTimeUnit(MultiTimeUnit):
@@ -47459,7 +26879,7 @@ class UtcMultiTimeUnit(MultiTimeUnit):
     _schema = {"$ref": "#/definitions/UtcMultiTimeUnit"}
 
     def __init__(self, *args):
-        super(UtcMultiTimeUnit, self).__init__(*args)
+        super().__init__(*args)
 
 
 class UtcSingleTimeUnit(SingleTimeUnit):
@@ -47468,7 +26888,7 @@ class UtcSingleTimeUnit(SingleTimeUnit):
     _schema = {"$ref": "#/definitions/UtcSingleTimeUnit"}
 
     def __init__(self, *args):
-        super(UtcSingleTimeUnit, self).__init__(*args)
+        super().__init__(*args)
 
 
 class VConcatSpecGenericSpec(Spec, NonNormalizedSpec):
@@ -47520,21 +26940,19 @@ class VConcatSpecGenericSpec(Spec, NonNormalizedSpec):
 
     def __init__(
         self,
-        vconcat: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        bounds: Union[Literal["full", "flush"], UndefinedType] = Undefined,
-        center: Union[bool, UndefinedType] = Undefined,
-        data: Union[dict, None, "SchemaBase", UndefinedType] = Undefined,
-        description: Union[str, UndefinedType] = Undefined,
-        name: Union[str, UndefinedType] = Undefined,
-        resolve: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        spacing: Union[float, UndefinedType] = Undefined,
-        title: Union[str, dict, "SchemaBase", Sequence[str], UndefinedType] = Undefined,
-        transform: Union[
-            Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
+        vconcat: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        bounds: Optional[Literal["full", "flush"]] = Undefined,
+        center: Optional[bool] = Undefined,
+        data: Optional[dict | None | SchemaBase] = Undefined,
+        description: Optional[str] = Undefined,
+        name: Optional[str] = Undefined,
+        resolve: Optional[dict | SchemaBase] = Undefined,
+        spacing: Optional[float] = Undefined,
+        title: Optional[str | dict | SchemaBase | Sequence[str]] = Undefined,
+        transform: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(VConcatSpecGenericSpec, self).__init__(
+        super().__init__(
             vconcat=vconcat,
             bounds=bounds,
             center=center,
@@ -47571,17 +26989,13 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull(
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(
-            ValueDefWithConditionMarkPropFieldOrDatumDefGradientstringnull, self
-        ).__init__(condition=condition, value=value, **kwds)
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull(
@@ -47606,17 +27020,13 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull(
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(
-            ValueDefWithConditionMarkPropFieldOrDatumDefTypeForShapestringnull, self
-        ).__init__(condition=condition, value=value, **kwds)
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class ValueDefWithConditionMarkPropFieldOrDatumDefnumber(
@@ -47641,17 +27051,13 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefnumber(
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        value: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        value: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ValueDefWithConditionMarkPropFieldOrDatumDefnumber, self).__init__(
-            condition=condition, value=value, **kwds
-        )
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class ValueDefWithConditionMarkPropFieldOrDatumDefnumberArray(
@@ -47676,17 +27082,13 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefnumberArray(
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        value: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        value: Optional[dict | Parameter | SchemaBase | Sequence[float]] = Undefined,
         **kwds,
     ):
-        super(ValueDefWithConditionMarkPropFieldOrDatumDefnumberArray, self).__init__(
-            condition=condition, value=value, **kwds
-        )
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class ValueDefWithConditionMarkPropFieldOrDatumDefstringnull(VegaLiteSchema):
@@ -47709,17 +27111,13 @@ class ValueDefWithConditionMarkPropFieldOrDatumDefstringnull(VegaLiteSchema):
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
-        ] = Undefined,
-        value: Union[
-            str, dict, None, "_Parameter", "SchemaBase", UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
+        value: Optional[str | dict | None | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ValueDefWithConditionMarkPropFieldOrDatumDefstringnull, self).__init__(
-            condition=condition, value=value, **kwds
-        )
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class ValueDefWithConditionStringFieldDefText(TextDef):
@@ -47740,17 +27138,15 @@ class ValueDefWithConditionStringFieldDefText(TextDef):
 
     def __init__(
         self,
-        condition: Union[
-            dict, "SchemaBase", Sequence[Union[dict, "SchemaBase"]], UndefinedType
+        condition: Optional[
+            dict | SchemaBase | Sequence[dict | SchemaBase]
         ] = Undefined,
-        value: Union[
-            str, dict, "_Parameter", "SchemaBase", Sequence[str], UndefinedType
+        value: Optional[
+            str | dict | Parameter | SchemaBase | Sequence[str]
         ] = Undefined,
         **kwds,
     ):
-        super(ValueDefWithConditionStringFieldDefText, self).__init__(
-            condition=condition, value=value, **kwds
-        )
+        super().__init__(condition=condition, value=value, **kwds)
 
 
 class ValueDefnumber(OffsetDef):
@@ -47769,8 +27165,8 @@ class ValueDefnumber(OffsetDef):
 
     _schema = {"$ref": "#/definitions/ValueDef<number>"}
 
-    def __init__(self, value: Union[float, UndefinedType] = Undefined, **kwds):
-        super(ValueDefnumber, self).__init__(value=value, **kwds)
+    def __init__(self, value: Optional[float] = Undefined, **kwds):
+        super().__init__(value=value, **kwds)
 
 
 class ValueDefnumberwidthheightExprRef(VegaLiteSchema):
@@ -47791,12 +27187,10 @@ class ValueDefnumberwidthheightExprRef(VegaLiteSchema):
 
     def __init__(
         self,
-        value: Union[
-            str, dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        value: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ValueDefnumberwidthheightExprRef, self).__init__(value=value, **kwds)
+        super().__init__(value=value, **kwds)
 
 
 class VariableParameter(TopLevelParameter):
@@ -47828,15 +27222,13 @@ class VariableParameter(TopLevelParameter):
 
     def __init__(
         self,
-        name: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        bind: Union[dict, "SchemaBase", UndefinedType] = Undefined,
-        expr: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        value: Union[Any, UndefinedType] = Undefined,
+        name: Optional[str | SchemaBase] = Undefined,
+        bind: Optional[dict | SchemaBase] = Undefined,
+        expr: Optional[str | SchemaBase] = Undefined,
+        value: Optional[Any] = Undefined,
         **kwds,
     ):
-        super(VariableParameter, self).__init__(
-            name=name, bind=bind, expr=expr, value=value, **kwds
-        )
+        super().__init__(name=name, bind=bind, expr=expr, value=value, **kwds)
 
 
 class Vector10string(VegaLiteSchema):
@@ -47845,7 +27237,7 @@ class Vector10string(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Vector10<string>"}
 
     def __init__(self, *args):
-        super(Vector10string, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector12string(VegaLiteSchema):
@@ -47854,7 +27246,7 @@ class Vector12string(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Vector12<string>"}
 
     def __init__(self, *args):
-        super(Vector12string, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector2DateTime(SelectionInitInterval):
@@ -47863,7 +27255,7 @@ class Vector2DateTime(SelectionInitInterval):
     _schema = {"$ref": "#/definitions/Vector2<DateTime>"}
 
     def __init__(self, *args):
-        super(Vector2DateTime, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector2Vector2number(VegaLiteSchema):
@@ -47872,7 +27264,7 @@ class Vector2Vector2number(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Vector2<Vector2<number>>"}
 
     def __init__(self, *args):
-        super(Vector2Vector2number, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector2boolean(SelectionInitInterval):
@@ -47881,7 +27273,7 @@ class Vector2boolean(SelectionInitInterval):
     _schema = {"$ref": "#/definitions/Vector2<boolean>"}
 
     def __init__(self, *args):
-        super(Vector2boolean, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector2number(SelectionInitInterval):
@@ -47890,7 +27282,7 @@ class Vector2number(SelectionInitInterval):
     _schema = {"$ref": "#/definitions/Vector2<number>"}
 
     def __init__(self, *args):
-        super(Vector2number, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector2string(SelectionInitInterval):
@@ -47899,7 +27291,7 @@ class Vector2string(SelectionInitInterval):
     _schema = {"$ref": "#/definitions/Vector2<string>"}
 
     def __init__(self, *args):
-        super(Vector2string, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector3number(VegaLiteSchema):
@@ -47908,7 +27300,7 @@ class Vector3number(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Vector3<number>"}
 
     def __init__(self, *args):
-        super(Vector3number, self).__init__(*args)
+        super().__init__(*args)
 
 
 class Vector7string(VegaLiteSchema):
@@ -47917,7 +27309,7 @@ class Vector7string(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/Vector7<string>"}
 
     def __init__(self, *args):
-        super(Vector7string, self).__init__(*args)
+        super().__init__(*args)
 
 
 class ViewBackground(VegaLiteSchema):
@@ -47986,406 +27378,29 @@ class ViewBackground(VegaLiteSchema):
 
     def __init__(
         self,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cursor: Optional[Cursor_T | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
         **kwds,
     ):
-        super(ViewBackground, self).__init__(
+        super().__init__(
             cornerRadius=cornerRadius,
             cursor=cursor,
             fill=fill,
@@ -48487,411 +27502,34 @@ class ViewConfig(VegaLiteSchema):
 
     def __init__(
         self,
-        clip: Union[bool, UndefinedType] = Undefined,
-        continuousHeight: Union[float, UndefinedType] = Undefined,
-        continuousWidth: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            "SchemaBase",
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        discreteHeight: Union[dict, float, UndefinedType] = Undefined,
-        discreteWidth: Union[dict, float, UndefinedType] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        step: Union[float, UndefinedType] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            "_Parameter",
-            "SchemaBase",
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, "_Parameter", "SchemaBase", Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            "_Parameter",
-            "SchemaBase",
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, "_Parameter", "SchemaBase", UndefinedType
-        ] = Undefined,
+        clip: Optional[bool] = Undefined,
+        continuousHeight: Optional[float] = Undefined,
+        continuousWidth: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cursor: Optional[Cursor_T | SchemaBase] = Undefined,
+        discreteHeight: Optional[dict | float] = Undefined,
+        discreteWidth: Optional[dict | float] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        step: Optional[float] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ):
-        super(ViewConfig, self).__init__(
+        super().__init__(
             clip=clip,
             continuousHeight=continuousHeight,
             continuousWidth=continuousWidth,
@@ -48921,7 +27559,7 @@ class WindowEventType(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/WindowEventType"}
 
     def __init__(self, *args, **kwds):
-        super(WindowEventType, self).__init__(*args, **kwds)
+        super().__init__(*args, **kwds)
 
 
 class EventType(WindowEventType):
@@ -48930,7 +27568,7 @@ class EventType(WindowEventType):
     _schema = {"$ref": "#/definitions/EventType"}
 
     def __init__(self, *args):
-        super(EventType, self).__init__(*args)
+        super().__init__(*args)
 
 
 class WindowFieldDef(VegaLiteSchema):
@@ -48961,55 +27599,12 @@ class WindowFieldDef(VegaLiteSchema):
 
     def __init__(
         self,
-        op: Union[
-            "SchemaBase",
-            Literal[
-                "row_number",
-                "rank",
-                "dense_rank",
-                "percent_rank",
-                "cume_dist",
-                "ntile",
-                "lag",
-                "lead",
-                "first_value",
-                "last_value",
-                "nth_value",
-            ],
-            Literal[
-                "argmax",
-                "argmin",
-                "average",
-                "count",
-                "distinct",
-                "max",
-                "mean",
-                "median",
-                "min",
-                "missing",
-                "product",
-                "q1",
-                "q3",
-                "ci0",
-                "ci1",
-                "stderr",
-                "stdev",
-                "stdevp",
-                "sum",
-                "valid",
-                "values",
-                "variance",
-                "variancep",
-                "exponential",
-                "exponentialb",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        field: Union[str, "SchemaBase", UndefinedType] = Undefined,
-        param: Union[float, UndefinedType] = Undefined,
+        op: Optional[SchemaBase | AggregateOp_T | WindowOnlyOp_T] = Undefined,
+        field: Optional[str | SchemaBase] = Undefined,
+        param: Optional[float] = Undefined,
         **kwds,
     ):
-        super(WindowFieldDef, self).__init__(op=op, field=field, param=param, **kwds)
+        super().__init__(op=op, field=field, param=param, **kwds)
 
 
 class WindowOnlyOp(VegaLiteSchema):
@@ -49018,7 +27613,7 @@ class WindowOnlyOp(VegaLiteSchema):
     _schema = {"$ref": "#/definitions/WindowOnlyOp"}
 
     def __init__(self, *args):
-        super(WindowOnlyOp, self).__init__(*args)
+        super().__init__(*args)
 
 
 class WindowTransform(Transform):
@@ -49070,14 +27665,14 @@ class WindowTransform(Transform):
 
     def __init__(
         self,
-        window: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
-        frame: Union[Sequence[Union[None, float]], UndefinedType] = Undefined,
-        groupby: Union[Sequence[Union[str, "SchemaBase"]], UndefinedType] = Undefined,
-        ignorePeers: Union[bool, UndefinedType] = Undefined,
-        sort: Union[Sequence[Union[dict, "SchemaBase"]], UndefinedType] = Undefined,
+        window: Optional[Sequence[dict | SchemaBase]] = Undefined,
+        frame: Optional[Sequence[None | float]] = Undefined,
+        groupby: Optional[Sequence[str | SchemaBase]] = Undefined,
+        ignorePeers: Optional[bool] = Undefined,
+        sort: Optional[Sequence[dict | SchemaBase]] = Undefined,
         **kwds,
     ):
-        super(WindowTransform, self).__init__(
+        super().__init__(
             window=window,
             frame=frame,
             groupby=groupby,
diff --git a/altair/vegalite/v5/schema/mixins.py b/altair/vegalite/v5/schema/mixins.py
index 24002b68e..692fc16b2 100644
--- a/altair/vegalite/v5/schema/mixins.py
+++ b/altair/vegalite/v5/schema/mixins.py
@@ -1,13 +1,18 @@
 # The contents of this file are automatically written by
 # tools/generate_schema_wrapper.py. Do not modify directly.
 
+from __future__ import annotations
+
 import sys
+from typing import TYPE_CHECKING, Literal, Sequence
 
+from altair.utils import use_signature
+from altair.utils.schemapi import Undefined
 
 from . import core
-from altair.utils import use_signature
-from altair.utils.schemapi import Undefined, UndefinedType
-from typing import Any, Sequence, List, Literal, Union
+
+if TYPE_CHECKING:
+    from altair import Parameter, SchemaBase
 
 
 if sys.version_info >= (3, 11):
@@ -16,833 +21,124 @@
     from typing_extensions import Self
 
 
+# ruff: noqa: F405
+if TYPE_CHECKING:
+    from altair.utils.schemapi import Optional
+
+    from ._typing import *  # noqa: F403
+
+
 class MarkMethodMixin:
     """A mixin class that defines mark methods"""
 
     def mark_arc(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'arc' (see :class:`MarkDef`)"""
@@ -944,828 +240,112 @@ def mark_arc(
 
     def mark_area(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'area' (see :class:`MarkDef`)"""
@@ -1867,828 +447,112 @@ def mark_area(
 
     def mark_bar(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'bar' (see :class:`MarkDef`)"""
@@ -2790,828 +654,112 @@ def mark_bar(
 
     def mark_image(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'image' (see :class:`MarkDef`)"""
@@ -3713,828 +861,112 @@ def mark_image(
 
     def mark_line(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'line' (see :class:`MarkDef`)"""
@@ -4636,828 +1068,112 @@ def mark_line(
 
     def mark_point(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'point' (see :class:`MarkDef`)"""
@@ -5559,828 +1275,112 @@ def mark_point(
 
     def mark_rect(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'rect' (see :class:`MarkDef`)"""
@@ -6482,828 +1482,112 @@ def mark_rect(
 
     def mark_rule(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'rule' (see :class:`MarkDef`)"""
@@ -7405,828 +1689,112 @@ def mark_rule(
 
     def mark_text(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'text' (see :class:`MarkDef`)"""
@@ -8328,828 +1896,112 @@ def mark_text(
 
     def mark_tick(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'tick' (see :class:`MarkDef`)"""
@@ -9251,828 +2103,112 @@ def mark_tick(
 
     def mark_trail(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'trail' (see :class:`MarkDef`)"""
@@ -10174,828 +2310,112 @@ def mark_trail(
 
     def mark_circle(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'circle' (see :class:`MarkDef`)"""
@@ -11097,828 +2517,112 @@ def mark_circle(
 
     def mark_square(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'square' (see :class:`MarkDef`)"""
@@ -12020,828 +2724,112 @@ def mark_square(
 
     def mark_geoshape(
         self,
-        align: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["left", "center", "right"],
-            UndefinedType,
-        ] = Undefined,
-        angle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aria: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRole: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ariaRoleDescription: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        aspect: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        bandSize: Union[float, UndefinedType] = Undefined,
-        baseline: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["top", "middle", "bottom"],
-            UndefinedType,
-        ] = Undefined,
-        binSpacing: Union[float, UndefinedType] = Undefined,
-        blend: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                None,
-                "multiply",
-                "screen",
-                "overlay",
-                "darken",
-                "lighten",
-                "color-dodge",
-                "color-burn",
-                "hard-light",
-                "soft-light",
-                "difference",
-                "exclusion",
-                "hue",
-                "saturation",
-                "color",
-                "luminosity",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        clip: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        continuousBandSize: Union[float, UndefinedType] = Undefined,
-        cornerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusBottomRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusEnd: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopLeft: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cornerRadiusTopRight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        cursor: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "auto",
-                "default",
-                "none",
-                "context-menu",
-                "help",
-                "pointer",
-                "progress",
-                "wait",
-                "cell",
-                "crosshair",
-                "text",
-                "vertical-text",
-                "alias",
-                "copy",
-                "move",
-                "no-drop",
-                "not-allowed",
-                "e-resize",
-                "n-resize",
-                "ne-resize",
-                "nw-resize",
-                "s-resize",
-                "se-resize",
-                "sw-resize",
-                "w-resize",
-                "ew-resize",
-                "ns-resize",
-                "nesw-resize",
-                "nwse-resize",
-                "col-resize",
-                "row-resize",
-                "all-scroll",
-                "zoom-in",
-                "zoom-out",
-                "grab",
-                "grabbing",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        description: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dir: Union[
-            dict, core._Parameter, core.SchemaBase, Literal["ltr", "rtl"], UndefinedType
-        ] = Undefined,
-        discreteBandSize: Union[
-            dict, float, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dx: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        dy: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        ellipsis: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fill: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        fillOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        filled: Union[bool, UndefinedType] = Undefined,
-        font: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontStyle: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        fontWeight: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "normal",
-                "bold",
-                "lighter",
-                "bolder",
-                100,
-                200,
-                300,
-                400,
-                500,
-                600,
-                700,
-                800,
-                900,
-            ],
-            UndefinedType,
-        ] = Undefined,
-        height: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        href: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        innerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        limit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        line: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        lineBreak: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        lineHeight: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        minBandSize: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        opacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        order: Union[bool, None, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outerRadius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        padAngle: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        point: Union[str, bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        radius: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radius2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        radiusOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        shape: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        size: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        smooth: Union[
-            bool, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        stroke: Union[
-            str,
-            dict,
-            None,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        strokeCap: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["butt", "round", "square"],
-            UndefinedType,
-        ] = Undefined,
-        strokeDash: Union[
-            dict, core._Parameter, core.SchemaBase, Sequence[float], UndefinedType
-        ] = Undefined,
-        strokeDashOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeJoin: Union[
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal["miter", "round", "bevel"],
-            UndefinedType,
-        ] = Undefined,
-        strokeMiterLimit: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeOpacity: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        strokeWidth: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        style: Union[str, Sequence[str], UndefinedType] = Undefined,
-        tension: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        text: Union[
-            str, dict, Sequence[str], core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        theta2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thetaOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        timeUnitBandPosition: Union[float, UndefinedType] = Undefined,
-        timeUnitBandSize: Union[float, UndefinedType] = Undefined,
-        tooltip: Union[
-            str,
-            bool,
-            dict,
-            None,
-            float,
-            core._Parameter,
-            core.SchemaBase,
-            UndefinedType,
-        ] = Undefined,
-        url: Union[
-            str, dict, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        width: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        x2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        xOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2: Union[
-            str, dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        y2Offset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
-        yOffset: Union[
-            dict, float, core._Parameter, core.SchemaBase, UndefinedType
-        ] = Undefined,
+        align: Optional[dict | Align_T | Parameter | SchemaBase] = Undefined,
+        angle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        aria: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        ariaRole: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        ariaRoleDescription: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        aspect: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        bandSize: Optional[float] = Undefined,
+        baseline: Optional[
+            str | dict | Baseline_T | Parameter | SchemaBase
+        ] = Undefined,
+        binSpacing: Optional[float] = Undefined,
+        blend: Optional[dict | Blend_T | Parameter | SchemaBase] = Undefined,
+        clip: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        continuousBandSize: Optional[float] = Undefined,
+        cornerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusBottomLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusBottomRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusEnd: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        cornerRadiusTopLeft: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cornerRadiusTopRight: Optional[
+            dict | float | Parameter | SchemaBase
+        ] = Undefined,
+        cursor: Optional[dict | Cursor_T | Parameter | SchemaBase] = Undefined,
+        description: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        dir: Optional[dict | Parameter | SchemaBase | TextDirection_T] = Undefined,
+        discreteBandSize: Optional[dict | float | SchemaBase] = Undefined,
+        dx: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        dy: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        ellipsis: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fill: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        fillOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        filled: Optional[bool] = Undefined,
+        font: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        fontStyle: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        fontWeight: Optional[dict | Parameter | SchemaBase | FontWeight_T] = Undefined,
+        height: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        href: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        innerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        interpolate: Optional[
+            dict | Parameter | SchemaBase | Interpolate_T
+        ] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        limit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        line: Optional[bool | dict | SchemaBase] = Undefined,
+        lineBreak: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        lineHeight: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        minBandSize: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        opacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        order: Optional[bool | None] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outerRadius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        padAngle: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        point: Optional[str | bool | dict | SchemaBase] = Undefined,
+        radius: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radius2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        radiusOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        shape: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        size: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        smooth: Optional[bool | dict | Parameter | SchemaBase] = Undefined,
+        stroke: Optional[
+            str | dict | None | Parameter | ColorName_T | SchemaBase
+        ] = Undefined,
+        strokeCap: Optional[dict | Parameter | StrokeCap_T | SchemaBase] = Undefined,
+        strokeDash: Optional[
+            dict | Parameter | SchemaBase | Sequence[float]
+        ] = Undefined,
+        strokeDashOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeJoin: Optional[dict | Parameter | SchemaBase | StrokeJoin_T] = Undefined,
+        strokeMiterLimit: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeOpacity: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        strokeWidth: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        style: Optional[str | Sequence[str]] = Undefined,
+        tension: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        text: Optional[str | dict | Parameter | SchemaBase | Sequence[str]] = Undefined,
+        theta: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        theta2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thetaOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        thickness: Optional[float] = Undefined,
+        timeUnitBandPosition: Optional[float] = Undefined,
+        timeUnitBandSize: Optional[float] = Undefined,
+        tooltip: Optional[
+            str | bool | dict | None | float | Parameter | SchemaBase
+        ] = Undefined,
+        url: Optional[str | dict | Parameter | SchemaBase] = Undefined,
+        width: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        x: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        x2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        xOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        y: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2: Optional[str | dict | float | Parameter | SchemaBase] = Undefined,
+        y2Offset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
+        yOffset: Optional[dict | float | Parameter | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'geoshape' (see :class:`MarkDef`)"""
@@ -12943,176 +2931,18 @@ def mark_geoshape(
 
     def mark_boxplot(
         self,
-        box: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        clip: Union[bool, UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        extent: Union[str, float, UndefinedType] = Undefined,
-        invalid: Union[Literal["filter", None], UndefinedType] = Undefined,
-        median: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        opacity: Union[float, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        outliers: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        rule: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        size: Union[float, UndefinedType] = Undefined,
-        ticks: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
+        box: Optional[bool | dict | SchemaBase] = Undefined,
+        clip: Optional[bool] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        extent: Optional[str | float] = Undefined,
+        invalid: Optional[Literal["filter", None]] = Undefined,
+        median: Optional[bool | dict | SchemaBase] = Undefined,
+        opacity: Optional[float] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        outliers: Optional[bool | dict | SchemaBase] = Undefined,
+        rule: Optional[bool | dict | SchemaBase] = Undefined,
+        size: Optional[float] = Undefined,
+        ticks: Optional[bool | dict | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'boxplot' (see :class:`BoxPlotDef`)"""
@@ -13140,175 +2970,15 @@ def mark_boxplot(
 
     def mark_errorbar(
         self,
-        clip: Union[bool, UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        extent: Union[
-            core.SchemaBase, Literal["ci", "iqr", "stderr", "stdev"], UndefinedType
-        ] = Undefined,
-        opacity: Union[float, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        rule: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        size: Union[float, UndefinedType] = Undefined,
-        thickness: Union[float, UndefinedType] = Undefined,
-        ticks: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
+        clip: Optional[bool] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        extent: Optional[SchemaBase | ErrorBarExtent_T] = Undefined,
+        opacity: Optional[float] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        rule: Optional[bool | dict | SchemaBase] = Undefined,
+        size: Optional[float] = Undefined,
+        thickness: Optional[float] = Undefined,
+        ticks: Optional[bool | dict | SchemaBase] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'errorbar' (see :class:`ErrorBarDef`)"""
@@ -13333,195 +3003,15 @@ def mark_errorbar(
 
     def mark_errorband(
         self,
-        band: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        borders: Union[bool, dict, core.SchemaBase, UndefinedType] = Undefined,
-        clip: Union[bool, UndefinedType] = Undefined,
-        color: Union[
-            str,
-            dict,
-            core._Parameter,
-            core.SchemaBase,
-            Literal[
-                "black",
-                "silver",
-                "gray",
-                "white",
-                "maroon",
-                "red",
-                "purple",
-                "fuchsia",
-                "green",
-                "lime",
-                "olive",
-                "yellow",
-                "navy",
-                "blue",
-                "teal",
-                "aqua",
-                "orange",
-                "aliceblue",
-                "antiquewhite",
-                "aquamarine",
-                "azure",
-                "beige",
-                "bisque",
-                "blanchedalmond",
-                "blueviolet",
-                "brown",
-                "burlywood",
-                "cadetblue",
-                "chartreuse",
-                "chocolate",
-                "coral",
-                "cornflowerblue",
-                "cornsilk",
-                "crimson",
-                "cyan",
-                "darkblue",
-                "darkcyan",
-                "darkgoldenrod",
-                "darkgray",
-                "darkgreen",
-                "darkgrey",
-                "darkkhaki",
-                "darkmagenta",
-                "darkolivegreen",
-                "darkorange",
-                "darkorchid",
-                "darkred",
-                "darksalmon",
-                "darkseagreen",
-                "darkslateblue",
-                "darkslategray",
-                "darkslategrey",
-                "darkturquoise",
-                "darkviolet",
-                "deeppink",
-                "deepskyblue",
-                "dimgray",
-                "dimgrey",
-                "dodgerblue",
-                "firebrick",
-                "floralwhite",
-                "forestgreen",
-                "gainsboro",
-                "ghostwhite",
-                "gold",
-                "goldenrod",
-                "greenyellow",
-                "grey",
-                "honeydew",
-                "hotpink",
-                "indianred",
-                "indigo",
-                "ivory",
-                "khaki",
-                "lavender",
-                "lavenderblush",
-                "lawngreen",
-                "lemonchiffon",
-                "lightblue",
-                "lightcoral",
-                "lightcyan",
-                "lightgoldenrodyellow",
-                "lightgray",
-                "lightgreen",
-                "lightgrey",
-                "lightpink",
-                "lightsalmon",
-                "lightseagreen",
-                "lightskyblue",
-                "lightslategray",
-                "lightslategrey",
-                "lightsteelblue",
-                "lightyellow",
-                "limegreen",
-                "linen",
-                "magenta",
-                "mediumaquamarine",
-                "mediumblue",
-                "mediumorchid",
-                "mediumpurple",
-                "mediumseagreen",
-                "mediumslateblue",
-                "mediumspringgreen",
-                "mediumturquoise",
-                "mediumvioletred",
-                "midnightblue",
-                "mintcream",
-                "mistyrose",
-                "moccasin",
-                "navajowhite",
-                "oldlace",
-                "olivedrab",
-                "orangered",
-                "orchid",
-                "palegoldenrod",
-                "palegreen",
-                "paleturquoise",
-                "palevioletred",
-                "papayawhip",
-                "peachpuff",
-                "peru",
-                "pink",
-                "plum",
-                "powderblue",
-                "rosybrown",
-                "royalblue",
-                "saddlebrown",
-                "salmon",
-                "sandybrown",
-                "seagreen",
-                "seashell",
-                "sienna",
-                "skyblue",
-                "slateblue",
-                "slategray",
-                "slategrey",
-                "snow",
-                "springgreen",
-                "steelblue",
-                "tan",
-                "thistle",
-                "tomato",
-                "turquoise",
-                "violet",
-                "wheat",
-                "whitesmoke",
-                "yellowgreen",
-                "rebeccapurple",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        extent: Union[
-            core.SchemaBase, Literal["ci", "iqr", "stderr", "stdev"], UndefinedType
-        ] = Undefined,
-        interpolate: Union[
-            core.SchemaBase,
-            Literal[
-                "basis",
-                "basis-open",
-                "basis-closed",
-                "bundle",
-                "cardinal",
-                "cardinal-open",
-                "cardinal-closed",
-                "catmull-rom",
-                "linear",
-                "linear-closed",
-                "monotone",
-                "natural",
-                "step",
-                "step-before",
-                "step-after",
-            ],
-            UndefinedType,
-        ] = Undefined,
-        opacity: Union[float, UndefinedType] = Undefined,
-        orient: Union[
-            core.SchemaBase, Literal["horizontal", "vertical"], UndefinedType
-        ] = Undefined,
-        tension: Union[float, UndefinedType] = Undefined,
+        band: Optional[bool | dict | SchemaBase] = Undefined,
+        borders: Optional[bool | dict | SchemaBase] = Undefined,
+        clip: Optional[bool] = Undefined,
+        color: Optional[str | dict | Parameter | ColorName_T | SchemaBase] = Undefined,
+        extent: Optional[SchemaBase | ErrorBarExtent_T] = Undefined,
+        interpolate: Optional[SchemaBase | Interpolate_T] = Undefined,
+        opacity: Optional[float] = Undefined,
+        orient: Optional[SchemaBase | Orientation_T] = Undefined,
+        tension: Optional[float] = Undefined,
         **kwds,
     ) -> Self:
         """Set the chart's mark to 'errorband' (see :class:`ErrorBandDef`)"""
diff --git a/altair/vegalite/v5/theme.py b/altair/vegalite/v5/theme.py
index bf99ad638..41af1a252 100644
--- a/altair/vegalite/v5/theme.py
+++ b/altair/vegalite/v5/theme.py
@@ -1,6 +1,7 @@
 """Tools for enabling and registering chart themes"""
 
-from typing import Dict, Union, Final
+from __future__ import annotations
+from typing import Final
 
 from ...utils.theme import ThemeRegistry
 
@@ -24,14 +25,14 @@ class VegaTheme:
     def __init__(self, theme: str) -> None:
         self.theme = theme
 
-    def __call__(self) -> Dict[str, Dict[str, Dict[str, Union[str, int]]]]:
+    def __call__(self) -> dict[str, dict[str, dict[str, str | int]]]:
         return {
             "usermeta": {"embedOptions": {"theme": self.theme}},
             "config": {"view": {"continuousWidth": 300, "continuousHeight": 300}},
         }
 
     def __repr__(self) -> str:
-        return "VegaTheme({!r})".format(self.theme)
+        return f"VegaTheme({self.theme!r})"
 
 
 # The entry point group that can be used by other packages to declare other
@@ -53,7 +54,7 @@ def __repr__(self) -> str:
         }
     },
 )
-themes.register("none", lambda: {})
+themes.register("none", dict)
 
 for theme in VEGA_THEMES:
     themes.register(theme, VegaTheme(theme))
diff --git a/doc/conf.py b/doc/conf.py
index 019ac9edd..fb33c95d4 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -19,7 +19,7 @@
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-sys.path.insert(0, os.path.abspath(".."))
+sys.path.insert(0, os.path.abspath(".."))  # noqa: PTH100
 
 # -- General configuration ------------------------------------------------
 
@@ -70,7 +70,7 @@
 
 # General information about the project.
 project = "Vega-Altair"
-copyright = "2016-{}, Vega-Altair Developers".format(datetime.now().year)
+copyright = f"2016-{datetime.now().year}, Vega-Altair Developers"
 author = "Vega-Altair Developers"
 
 # The version info for the project you're documenting, acts as replacement for
diff --git a/pyproject.toml b/pyproject.toml
index ba6de061a..ea128f70e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -70,6 +70,7 @@ dev = [
     "ipython",
     "pytest",
     "pytest-cov",
+    "pytest-xdist[psutil]~=3.5",
     "m2r",
     "mypy",
     "pandas-stubs",
@@ -103,16 +104,47 @@ artifacts = ["altair/jupyter/js/index.js"]
 
 [tool.hatch.envs.default]
 features = ["all", "dev"]
+# https://hatch.pypa.io/latest/how-to/environment/select-installer/#enabling-uv
+installer = "uv"
 
 [tool.hatch.envs.default.scripts]
+generate-schema-wrapper = [
+    "mypy tools/schemapi/schemapi.py",
+    "python tools/generate_schema_wrapper.py",
+    "test"
+]
 test = [
     "ruff check .",
     "ruff format --diff --check .",
     "mypy altair tests",
-    "python -m pytest --pyargs --doctest-modules tests altair",
+    "python -m pytest --pyargs --numprocesses=logical --doctest-modules tests altair",
 ]
 test-coverage = "python -m pytest --pyargs --doctest-modules --cov=altair --cov-report term altair"
 test-coverage-html = "python -m pytest --pyargs --doctest-modules --cov=altair --cov-report html altair"
+update-init-file = [
+    "python tools/update_init_file.py",
+    "ruff check .",
+    "ruff format .",
+]
+
+[tool.hatch.envs.hatch-test]
+# https://hatch.pypa.io/latest/tutorials/testing/overview/
+features = ["all", "dev", "doc"]
+# https://pytest-xdist.readthedocs.io/en/latest/distribution.html#running-tests-across-multiple-cpus
+default-args = ["--numprocesses=logical","--doctest-modules", "tests", "altair"]
+parallel = true
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
+[tool.hatch.envs.hatch-test.scripts]
+run = [
+    "ruff check .", 
+    "ruff format --diff --check .",
+    "mypy altair tests",
+    "pytest{env:HATCH_TEST_ARGS:} {args}"
+]
+run-cov = "coverage run -m pytest{env:HATCH_TEST_ARGS:} {args}"
+cov-combine = "coverage combine"
+cov-report = "coverage report"
 
 [tool.hatch.envs.doc]
 features = ["all", "dev", "doc"]
@@ -163,7 +195,46 @@ exclude = [
 ]
 
 [tool.ruff.lint]
-extend-safe-fixes=["SIM101"]
+# https://docs.astral.sh/ruff/preview/
+preview = true
+
+# https://docs.astral.sh/ruff/settings/#lint_extend-safe-fixes
+extend-safe-fixes=[
+    # unnecessary-comprehension-in-call
+    "C419",
+    # literal-membership
+    "PLR6201",
+    # from __future__ import annotations #
+    # ---------------------------------- # 
+    "UP006",
+    "UP007",
+    "UP008",
+    "TCH",
+    # assign exception msg to variable #
+    # -------------------------------- #
+    "EM101",
+    "EM102",
+    # trailing-whitespace
+    "W291",
+]
+
+# https://docs.astral.sh/ruff/preview/#using-rules-that-are-in-preview
+extend-select=[
+    # refurb
+    "FURB", 
+    # pylint (preview) autofix #
+    # ------------------------ #
+    # unnecessary-dunder-call
+    "PLC2801", 
+    # unnecessary-dict-index-lookup
+    "PLR1733", 
+    # unnecessary-list-index-lookup
+    "PLR1736",
+    # literal-membership
+    "PLR6201",
+    # unspecified-encoding
+    "PLW1514",
+]
 select = [
     # flake8-bugbear
     "B",
@@ -171,14 +242,52 @@ select = [
     "C4",
     # pycodestyle-error
     "E",
-    # pycodestyle-warning
-    "W",
+    # flake8-errmsg
+    "EM",
     # pyflakes
     "F",
+    # flake8-future-annotations
+    "FA",
+    # flynt
+    "FLY",
+    # flake8-pie
+    "PIE",
+    # flake8-pytest-style
+    "PT",
+    # flake8-use-pathlib
+    "PTH",
+    # Ruff-specific rules
+    "RUF",
+    # flake8-simplify
+    "SIM",
+    # flake8-type-checking
+    "TCH",
     # flake8-tidy-imports
     "TID",
-    # flake8-simplify
-    "SIM101"
+    # pyupgrade
+    "UP",
+    # pycodestyle-warning
+    "W",
+    # pylint (stable) autofix #
+    # ----------------------- #
+    # iteration-over-set
+    "PLC0208",
+    # manual-from-import
+    "PLR0402",
+    # repeated-isinstance-calls
+    "PLR1701",
+    # useless-return
+    "PLR1711",
+    # repeated-equality-comparison
+    "PLR1714",
+    # collapsible-else-if
+    "PLR5501",
+    # useless-else-on-loop
+    "PLW0120",
+    # subprocess-run-without-check
+    "PLW1510",
+    # nested-min-max
+    "PLW3301",
 ]
 ignore = [  
     # Whitespace before ':'
@@ -192,22 +301,36 @@ ignore = [
     # zip() without an explicit strict= parameter set.
     # python>=3.10 only
     "B905",
+    # mutable-class-default
+    "RUF012",
+    # suppressible-exception
+    # https://github.com/vega/altair/pull/3431#discussion_r1629808660
+    "SIM105",
 ]
 
+# https://docs.astral.sh/ruff/settings/#lint_unfixable
+unfixable= [
+    # unspecified-encoding
+    # The autofix is unsafe and doesn't reliably produce `utf-8`.
+    # However, it still needs to be flagged as error until `python>=3.10`.
+    "PLW1514"
+]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 18
+
 [tool.ruff.format]
 quote-style = "double"
 indent-style = "space"
 skip-magic-trailing-comma = false
 line-ending = "lf"
 
-[tool.ruff.lint.mccabe]
-max-complexity = 18
-
 [tool.pytest.ini_options]
 # Pytest does not need to search these folders for test functions.
 # They contain examples which are being executed by the
 # test_examples tests.
 norecursedirs = ["tests/examples_arguments_syntax", "tests/examples_methods_syntax"]
+addopts = ["--numprocesses=logical"]
 
 [tool.mypy]
 warn_unused_ignores = true
@@ -229,3 +352,8 @@ module = [
     "schemapi.*"
 ]
 ignore_missing_imports = true
+
+[tool.pyright]
+extraPaths=["./tools"]
+pythonPlatform="All"
+pythonVersion="3.8"
\ No newline at end of file
diff --git a/sphinxext/altairgallery.py b/sphinxext/altairgallery.py
index a6310ddd9..a17eeb28e 100644
--- a/sphinxext/altairgallery.py
+++ b/sphinxext/altairgallery.py
@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import hashlib
-import os
 import json
+from pathlib import Path
 import random
 import collections
 from operator import itemgetter
 import warnings
 import shutil
+from typing import Any, TYPE_CHECKING
 
 import jinja2
 
@@ -26,6 +29,9 @@
 from tests.examples_arguments_syntax import iter_examples_arguments_syntax
 from tests.examples_methods_syntax import iter_examples_methods_syntax
 
+if TYPE_CHECKING:
+    from docutils.nodes import Node
+
 
 EXAMPLE_MODULE = "altair.examples"
 
@@ -148,33 +154,38 @@
 )
 
 
-def save_example_pngs(examples, image_dir, make_thumbnails=True):
+def save_example_pngs(
+    examples: list[dict[str, Any]], image_dir: Path, make_thumbnails: bool = True
+) -> None:
     """Save example pngs and (optionally) thumbnails"""
-    if not os.path.exists(image_dir):
-        os.makedirs(image_dir)
+    encoding = "utf-8"
 
     # store hashes so that we know whether images need to be generated
-    hash_file = os.path.join(image_dir, "_image_hashes.json")
+    hash_file: Path = image_dir / "_image_hashes.json"
 
-    if os.path.exists(hash_file):
-        with open(hash_file) as f:
+    if hash_file.exists():
+        with hash_file.open(encoding=encoding) as f:
             hashes = json.load(f)
     else:
         hashes = {}
 
     for example in examples:
-        filename = example["name"] + (".svg" if example["use_svg"] else ".png")
-        image_file = os.path.join(image_dir, filename)
+        name: str = example["name"]
+        use_svg: bool = example["use_svg"]
+        code = example["code"]
+
+        filename = name + (".svg" if use_svg else ".png")
+        image_file = image_dir / filename
 
-        example_hash = hashlib.sha256(example["code"].encode()).hexdigest()[:32]
+        example_hash = hashlib.sha256(code.encode()).hexdigest()[:32]
         hashes_match = hashes.get(filename, "") == example_hash
 
-        if hashes_match and os.path.exists(image_file):
-            print("-> using cached {}".format(image_file))
+        if hashes_match and image_file.exists():
+            print(f"-> using cached {image_file!s}")
         else:
             # the file changed or the image file does not exist. Generate it.
-            print("-> saving {}".format(image_file))
-            chart = eval_block(example["code"])
+            print(f"-> saving {image_file!s}")
+            chart = eval_block(code)
             try:
                 chart.save(image_file)
                 hashes[filename] = example_hash
@@ -182,25 +193,23 @@ def save_example_pngs(examples, image_dir, make_thumbnails=True):
                 warnings.warn("Unable to save image: using generic image", stacklevel=1)
                 create_generic_image(image_file)
 
-            with open(hash_file, "w") as f:
+            with hash_file.open("w", encoding=encoding) as f:
                 json.dump(hashes, f)
 
         if make_thumbnails:
             params = example.get("galleryParameters", {})
-            if example["use_svg"]:
+            if use_svg:
                 # Thumbnail for SVG is identical to original image
-                thumb_file = os.path.join(image_dir, example["name"] + "-thumb.svg")
-                shutil.copyfile(image_file, thumb_file)
+                shutil.copyfile(image_file, image_dir / f"{name}-thumb.svg")
             else:
-                thumb_file = os.path.join(image_dir, example["name"] + "-thumb.png")
-                create_thumbnail(image_file, thumb_file, **params)
+                create_thumbnail(image_file, image_dir / f"{name}-thumb.png", **params)
 
     # Save hashes so we know whether we need to re-generate plots
-    with open(hash_file, "w") as f:
+    with hash_file.open("w", encoding=encoding) as f:
         json.dump(hashes, f)
 
 
-def populate_examples(**kwds):
+def populate_examples(**kwds: Any) -> list[dict[str, Any]]:
     """Iterate through Altair examples and extract code"""
 
     examples = sorted(iter_examples_arguments_syntax(), key=itemgetter("name"))
@@ -208,7 +217,7 @@ def populate_examples(**kwds):
 
     for example in examples:
         docstring, category, code, lineno = get_docstring_and_rest(example["filename"])
-        if example["name"] in method_examples.keys():
+        if example["name"] in method_examples:
             _, _, method_code, _ = get_docstring_and_rest(
                 method_examples[example["name"]]["filename"]
             )
@@ -220,9 +229,8 @@ def populate_examples(**kwds):
             )
         example.update(kwds)
         if category is None:
-            raise Exception(
-                f"The example {example['name']} is not assigned to a category"
-            )
+            msg = f"The example {example['name']} is not assigned to a category"
+            raise Exception(msg)
         example.update(
             {
                 "docstring": docstring,
@@ -237,20 +245,24 @@ def populate_examples(**kwds):
     return examples
 
 
+def _indices(x: str, /) -> list[int]:
+    return [int(idx) for idx in x.split()]
+
+
 class AltairMiniGalleryDirective(Directive):
     has_content = False
 
     option_spec = {
         "size": int,
         "names": str,
-        "indices": lambda x: list(map(int, x.split())),
+        "indices": _indices,
         "shuffle": flag,
         "seed": int,
         "titles": bool,
         "width": str,
     }
 
-    def run(self):
+    def run(self) -> list[Node]:
         size = self.options.get("size", 15)
         names = [name.strip() for name in self.options.get("names", "").split(",")]
         indices = self.options.get("indices", [])
@@ -268,10 +280,11 @@ def run(self):
 
         if names:
             if len(names) < size:
-                raise ValueError(
+                msg = (
                     "altair-minigallery: if names are specified, "
                     "the list must be at least as long as size."
                 )
+                raise ValueError(msg)
             mapping = {example["name"]: example for example in examples}
             examples = [mapping[name] for name in names]
         else:
@@ -302,19 +315,19 @@ def run(self):
         return node.children
 
 
-def main(app):
-    gallery_dir = app.builder.config.altair_gallery_dir
-    target_dir = os.path.join(app.builder.srcdir, gallery_dir)
-    image_dir = os.path.join(app.builder.srcdir, "_images")
+def main(app) -> None:
+    src_dir = Path(app.builder.srcdir)
+    target_dir: Path = src_dir / Path(app.builder.config.altair_gallery_dir)
+    image_dir: Path = src_dir / "_images"
 
     gallery_ref = app.builder.config.altair_gallery_ref
     gallery_title = app.builder.config.altair_gallery_title
     examples = populate_examples(gallery_ref=gallery_ref, code_below=True, strict=False)
 
-    if not os.path.exists(target_dir):
-        os.makedirs(target_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+    image_dir.mkdir(exist_ok=True)
 
-    examples = sorted(examples, key=lambda x: x["title"])
+    examples = sorted(examples, key=itemgetter("title"))
     examples_toc = collections.OrderedDict(
         {
             "Simple Charts": [],
@@ -335,16 +348,19 @@ def main(app):
     for d in examples:
         examples_toc[d["category"]].append(d)
 
+    encoding = "utf-8"
+
     # Write the gallery index file
-    with open(os.path.join(target_dir, "index.rst"), "w") as f:
-        f.write(
-            GALLERY_TEMPLATE.render(
-                title=gallery_title,
-                examples=examples_toc.items(),
-                image_dir="/_static",
-                gallery_ref=gallery_ref,
-            )
-        )
+    fp = target_dir / "index.rst"
+    fp.write_text(
+        GALLERY_TEMPLATE.render(
+            title=gallery_title,
+            examples=examples_toc.items(),
+            image_dir="/_static",
+            gallery_ref=gallery_ref,
+        ),
+        encoding=encoding,
+    )
 
     # save the images to file
     save_example_pngs(examples, image_dir)
@@ -355,12 +371,11 @@ def main(app):
             example["prev_ref"] = "gallery_{name}".format(**prev_ex)
         if next_ex:
             example["next_ref"] = "gallery_{name}".format(**next_ex)
-        target_filename = os.path.join(target_dir, example["name"] + ".rst")
-        with open(os.path.join(target_filename), "w", encoding="utf-8") as f:
-            f.write(EXAMPLE_TEMPLATE.render(example))
+        fp = target_dir / "".join((example["name"], ".rst"))
+        fp.write_text(EXAMPLE_TEMPLATE.render(example), encoding=encoding)
 
 
-def setup(app):
+def setup(app) -> None:
     app.connect("builder-inited", main)
     app.add_css_file("altair-gallery.css")
     app.add_config_value("altair_gallery_dir", "gallery", "env")
diff --git a/sphinxext/schematable.py b/sphinxext/schematable.py
index c70060b32..484baf29a 100644
--- a/sphinxext/schematable.py
+++ b/sphinxext/schematable.py
@@ -1,20 +1,18 @@
+from __future__ import annotations
 import importlib
 import re
-import sys
+from typing import Any, Iterator, Sequence
 import warnings
-from os.path import abspath, dirname
-
 from docutils import nodes, utils, frontend
 from docutils.parsers.rst import Directive
 from docutils.parsers.rst.directives import flag
 from myst_parser.docutils_ import Parser
 from sphinx import addnodes
 
-sys.path.insert(0, abspath(dirname(dirname(dirname(__file__)))))
-from tools.schemapi.utils import fix_docstring_issues, SchemaInfo  # noqa: E402
+from tools.schemapi.utils import fix_docstring_issues, SchemaInfo
 
 
-def type_description(schema):
+def type_description(schema: dict[str, Any]) -> str:
     """Return a concise type description for the given schema"""
     if not schema or not isinstance(schema, dict) or schema.keys() == {"description"}:
         return "any"
@@ -37,13 +35,15 @@ def type_description(schema):
         )
     else:
         warnings.warn(
-            "cannot infer type for schema with keys {}" "".format(schema.keys()),
+            f"cannot infer type for schema with keys {schema.keys()}" "",
             stacklevel=1,
         )
         return "--"
 
 
-def prepare_table_header(titles, widths):
+def prepare_table_header(
+    titles: Sequence[str], widths: Sequence[float]
+) -> tuple[nodes.table, nodes.tbody]:
     """Build docutil empty table"""
     ncols = len(titles)
     assert len(widths) == ncols
@@ -66,7 +66,7 @@ def prepare_table_header(titles, widths):
 reCode = re.compile(r"`([^`]+)`")
 
 
-def add_class_def(node, classDef):
+def add_class_def(node: nodes.paragraph, classDef: str) -> nodes.paragraph:
     """Add reference on classDef to node"""
 
     ref = addnodes.pending_xref(
@@ -85,7 +85,7 @@ def add_class_def(node, classDef):
     return node
 
 
-def add_text(node, text):
+def add_text(node: nodes.paragraph, text: str) -> nodes.paragraph:
     """Add text with inline code to node"""
     is_text = True
     for part in reCode.split(text):
@@ -100,10 +100,12 @@ def add_text(node, text):
     return node
 
 
-def build_row(item, rootschema):
+def build_row(
+    item: tuple[str, dict[str, Any]], rootschema: dict[str, Any] | None
+) -> nodes.row:
     """Return nodes.row with property description"""
 
-    prop, propschema, required = item
+    prop, propschema, _ = item
     row = nodes.row()
 
     # Property
@@ -130,7 +132,7 @@ def build_row(item, rootschema):
     md_parser = Parser()
     # str_descr = "***Required.*** " if required else ""
     description = SchemaInfo(propschema, rootschema).deep_description
-    description = description if description else " "
+    description = description or " "
     str_descr = ""
     str_descr += description
     str_descr = fix_docstring_issues(str_descr)
@@ -145,7 +147,9 @@ def build_row(item, rootschema):
     return row
 
 
-def build_schema_table(items, rootschema):
+def build_schema_table(
+    items: Iterator[tuple[str, dict[str, Any]]], rootschema: dict[str, Any] | None
+) -> nodes.table:
     """Return schema table of items (iterator of prop, schema.item, required)"""
     table, tbody = prepare_table_header(
         ["Property", "Type", "Description"], [10, 20, 50]
@@ -156,7 +160,9 @@ def build_schema_table(items, rootschema):
     return table
 
 
-def select_items_from_schema(schema, props=None):
+def select_items_from_schema(
+    schema: dict[str, Any], props: list[str] | None = None
+) -> Iterator[tuple[Any, Any, bool] | tuple[str, Any, bool]]:
     """Return iterator  (prop, schema.item, required) on prop, return all in None"""
     properties = schema.get("properties", {})
     required = schema.get("required", [])
@@ -168,15 +174,20 @@ def select_items_from_schema(schema, props=None):
             try:
                 yield prop, properties[prop], prop in required
             except KeyError as err:
-                raise Exception(f"Can't find property: {prop}") from err
+                msg = f"Can't find property: {prop}"
+                raise Exception(msg) from err
 
 
-def prepare_schema_table(schema, rootschema, props=None):
+def prepare_schema_table(
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None,
+    props: list[str] | None = None,
+) -> nodes.table:
     items = select_items_from_schema(schema, props)
     return build_schema_table(items, rootschema)
 
 
-def validate_properties(properties):
+def validate_properties(properties: str) -> list[str]:
     return properties.strip().split()
 
 
@@ -195,11 +206,11 @@ class AltairObjectTableDirective(Directive):
 
     option_spec = {"properties": validate_properties, "dont-collapse-table": flag}
 
-    def run(self):
+    def run(self) -> list:
         objectname = self.arguments[0]
         modname, classname = objectname.rsplit(".", 1)
         module = importlib.import_module(modname)
-        cls = getattr(module, classname)
+        cls: type[Any] = getattr(module, classname)
         schema = cls.resolve_references(cls._schema)
 
         properties = self.options.get("properties", None)
@@ -221,5 +232,5 @@ def run(self):
         return result
 
 
-def setup(app):
+def setup(app) -> None:
     app.add_directive("altair-object-table", AltairObjectTableDirective)
diff --git a/sphinxext/utils.py b/sphinxext/utils.py
index 50d17608c..51c4f05d6 100644
--- a/sphinxext/utils.py
+++ b/sphinxext/utils.py
@@ -1,11 +1,19 @@
+from __future__ import annotations
+
 import ast
 import hashlib
 import itertools
 import json
+from pathlib import Path
 import re
+from typing import Any
 
 
-def create_thumbnail(image_filename, thumb_filename, window_size=(280, 160)):
+def create_thumbnail(
+    image_filename: Path,
+    thumb_filename: Path,
+    window_size: tuple[float, float] = (280, 160),
+) -> None:
     """Create a thumbnail whose shortest dimension matches the window"""
     from PIL import Image
 
@@ -26,7 +34,9 @@ def create_thumbnail(image_filename, thumb_filename, window_size=(280, 160)):
     thumb.save(thumb_filename)
 
 
-def create_generic_image(filename, shape=(200, 300), gradient=True):
+def create_generic_image(
+    filename: Path, shape: tuple[float, float] = (200, 300), gradient: bool = True
+) -> None:
     """Create a generic image"""
     from PIL import Image
     import numpy as np
@@ -48,7 +58,7 @@ def create_generic_image(filename, shape=(200, 300), gradient=True):
 """
 
 
-def _parse_source_file(filename):
+def _parse_source_file(filename: str) -> tuple[ast.Module | None, str]:
     """Parse source file into AST node
 
     Parameters
@@ -66,9 +76,7 @@ def _parse_source_file(filename):
     This function adapted from the sphinx-gallery project; license: BSD-3
     https://github.com/sphinx-gallery/sphinx-gallery/
     """
-
-    with open(filename, "r", encoding="utf-8") as fid:
-        content = fid.read()
+    content = Path(filename).read_text(encoding="utf-8")
     # change from Windows format to UNIX for uniformity
     content = content.replace("\r\n", "\n")
 
@@ -79,7 +87,7 @@ def _parse_source_file(filename):
     return node, content
 
 
-def get_docstring_and_rest(filename):
+def get_docstring_and_rest(filename: str) -> tuple[str, str | None, str, int]:
     """Separate ``filename`` content between docstring and the rest
 
     Strongly inspired from ast.get_docstring.
@@ -117,15 +125,14 @@ def get_docstring_and_rest(filename):
     else:
         category = None
 
+    lineno = 1
+
     if node is None:
-        return SYNTAX_ERROR_DOCSTRING, category, content, 1
+        return SYNTAX_ERROR_DOCSTRING, category, content, lineno
 
     if not isinstance(node, ast.Module):
-        raise TypeError(
-            "This function only supports modules. You provided {}".format(
-                node.__class__.__name__
-            )
-        )
+        msg = f"This function only supports modules. You provided {node.__class__.__name__}"
+        raise TypeError(msg)
     try:
         # In python 3.7 module knows its docstring.
         # Everything else will raise an attribute error
@@ -161,8 +168,8 @@ def get_docstring_and_rest(filename):
             if hasattr(docstring, "decode") and not isinstance(docstring, str):
                 docstring = docstring.decode("utf-8")
             # python3.8: has end_lineno
-            lineno = (
-                getattr(docstring_node, "end_lineno", None) or docstring_node.lineno
+            lineno = getattr(
+                docstring_node, "end_lineno", docstring_node.lineno
             )  # The last line of the string.
             # This get the content of the file after the docstring last line
             # Note: 'maxsplit' argument is not a keyword argument in python2
@@ -172,23 +179,24 @@ def get_docstring_and_rest(filename):
             docstring, rest = "", ""
 
     if not docstring:
-        raise ValueError(
-            (
-                'Could not find docstring in file "{0}". '
-                "A docstring is required for the example gallery."
-            ).format(filename)
+        msg = (
+            f'Could not find docstring in file "{filename}". '
+            "A docstring is required for the example gallery."
         )
+        raise ValueError(msg)
     return docstring, category, rest, lineno
 
 
-def prev_this_next(it, sentinel=None):
+def prev_this_next(
+    it: list[dict[str, Any]], sentinel: None = None
+) -> zip[tuple[dict[str, Any] | None, dict[str, Any], dict[str, Any] | None]]:
     """Utility to return (prev, this, next) tuples from an iterator"""
     i1, i2, i3 = itertools.tee(it, 3)
     next(i3, None)
     return zip(itertools.chain([sentinel], i1), i2, itertools.chain(i3, [sentinel]))
 
 
-def dict_hash(dct):
+def dict_hash(dct: dict[Any, Any]) -> Any:
     """Return a hash of the contents of a dictionary"""
     serialized = json.dumps(dct, sort_keys=True)
 
diff --git a/tests/expr/test_expr.py b/tests/expr/test_expr.py
index a5b6870bd..49d574176 100644
--- a/tests/expr/test_expr.py
+++ b/tests/expr/test_expr.py
@@ -12,7 +12,7 @@ def test_unary_operations():
     OP_MAP = {"-": operator.neg, "+": operator.pos}
     for op, func in OP_MAP.items():
         z = func(datum.xxx)
-        assert repr(z) == "({}datum.xxx)".format(op)
+        assert repr(z) == f"({op}datum.xxx)"
 
 
 def test_binary_operations():
@@ -42,16 +42,16 @@ def test_binary_operations():
     }
     for op, func in OP_MAP.items():
         z1 = func(datum.xxx, 2)
-        assert repr(z1) == "(datum.xxx {} 2)".format(op)
+        assert repr(z1) == f"(datum.xxx {op} 2)"
 
         z2 = func(2, datum.xxx)
         if op in INEQ_REVERSE:
-            assert repr(z2) == "(datum.xxx {} 2)".format(INEQ_REVERSE[op])
+            assert repr(z2) == f"(datum.xxx {INEQ_REVERSE[op]} 2)"
         else:
-            assert repr(z2) == "(2 {} datum.xxx)".format(op)
+            assert repr(z2) == f"(2 {op} datum.xxx)"
 
         z3 = func(datum.xxx, datum.yyy)
-        assert repr(z3) == "(datum.xxx {} datum.yyy)".format(op)
+        assert repr(z3) == f"(datum.xxx {op} datum.yyy)"
 
 
 def test_abs():
@@ -65,7 +65,7 @@ def test_expr_funcs():
     for funcname in expr.funcs.__all__:
         func = getattr(expr, funcname)
         z = func(datum.xxx)
-        assert repr(z) == "{}(datum.xxx)".format(name_map.get(funcname, funcname))
+        assert repr(z) == f"{name_map.get(funcname, funcname)}(datum.xxx)"
 
 
 def test_expr_consts():
@@ -74,7 +74,7 @@ def test_expr_consts():
     for constname in expr.consts.__all__:
         const = getattr(expr, constname)
         z = const * datum.xxx
-        assert repr(z) == "({} * datum.xxx)".format(name_map.get(constname, constname))
+        assert repr(z) == f"({name_map.get(constname, constname)} * datum.xxx)"
 
 
 def test_json_reprs():
diff --git a/tests/test_examples.py b/tests/test_examples.py
index 124b8a66b..4a449499b 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -1,6 +1,28 @@
+"""This module dominates the testing time.
+
+TODO
+----
+- Research how this could be done with fixtures.
+
+Other optimization ideas
+------------------
+Cache the calls to `compile` in `altair.utils.execeval`
+- The each file has every expression compiled 3x times
+- Would immediately reduce to 1x
+- Possible there are overlapping expressions between `examples_arguments_syntax` and `examples_methods_syntax`
+    - Could lead to further performance gains
+- All of the tests only call `eval_block` to operate on the finished chart
+    - The need to execute the code is not what is being tested
+
+"""
+
+from __future__ import annotations
+
 import io
 import pkgutil
-
+import sys
+from typing import Any, Iterable, Iterator
+import re
 import pytest
 
 import altair as alt
@@ -8,93 +30,119 @@
 from tests import examples_arguments_syntax
 from tests import examples_methods_syntax
 
-
 try:
-    import vl_convert as vlc  # noqa: F401
+    import vl_convert as vlc  # noqa: F401, RUF100
 except ImportError:
     vlc = None
 
 
-def iter_examples_filenames(syntax_module):
+VL_CONVERT_AVAILABLE = "vl_convert" in sys.modules
+
+
+def iter_examples_filenames(syntax_module) -> Iterator[str]:
     for _importer, modname, ispkg in pkgutil.iter_modules(syntax_module.__path__):
-        if (
+        if not (
             ispkg
             or modname.startswith("_")
             # Temporarily skip this test until https://github.com/vega/altair/issues/3418
             # is fixed
             or modname == "interval_selection_map_quakes"
         ):
-            continue
-        yield modname + ".py"
+            yield f"{modname}.py"
+
 
+def _distributed_examples() -> Iterator[tuple[Any, str]]:
+    # `pytest.mark.parametrize` over 2 modules produces 2x workers
+    # - This raises the total jobs from 400 -> 1200
+    # - Preventing the three tests from blocking everything else
+    RE_NAME: re.Pattern[str] = re.compile(r"^tests\.(.*)")
 
-@pytest.mark.parametrize(
-    "syntax_module", [examples_arguments_syntax, examples_methods_syntax]
+    for module in [examples_arguments_syntax, examples_methods_syntax]:
+        for filename in iter_examples_filenames(module):
+            name = module.__name__
+            source = pkgutil.get_data(name, filename)
+            yield source, f"{RE_NAME.match(name).group(1)}.{filename}"  # type: ignore[union-attr]
+
+
+distributed_examples: Iterable[tuple[Any, str]] = tuple(_distributed_examples())
+"""Tried using as a `fixture`, but wasn't able to combine with `@pytest.mark.parametrize`."""
+
+
+def id_func(val) -> str:
+    """Ensures the generated test-id name uses only `filename` and not `source`.
+
+    Without this, the name is repr(source code)-filename
+    """
+    if not isinstance(val, str):
+        return ""
+    else:
+        return val
+
+
+@pytest.mark.filterwarnings(
+    "ignore:'M' is deprecated.*:FutureWarning",
+    "ignore:DataFrameGroupBy.apply.*:DeprecationWarning",
 )
-def test_render_examples_to_chart(syntax_module):
-    for filename in iter_examples_filenames(syntax_module):
-        source = pkgutil.get_data(syntax_module.__name__, filename)
-        chart = eval_block(source)
-
-        if chart is None:
-            raise ValueError(
-                f"Example file {filename} should define chart in its final "
-                "statement."
-            )
-
-        try:
-            assert isinstance(chart.to_dict(), dict)
-        except Exception as err:
-            raise AssertionError(
-                f"Example file {filename} raised an exception when "
-                f"converting to a dict: {err}"
-            ) from err
-
-
-@pytest.mark.parametrize(
-    "syntax_module", [examples_arguments_syntax, examples_methods_syntax]
+@pytest.mark.parametrize(("source", "filename"), distributed_examples, ids=id_func)
+def test_render_examples_to_chart(source, filename) -> None:
+    chart = eval_block(source)
+    if chart is None:
+        msg = f"Example file {filename} should define chart in its final statement."
+        raise ValueError(msg)
+    try:
+        assert isinstance(chart.to_dict(), dict)
+    except Exception as err:
+        msg = (
+            f"Example file {filename} raised an exception when "
+            f"converting to a dict: {err}"
+        )
+        raise AssertionError(msg) from err
+
+
+@pytest.mark.filterwarnings(
+    "ignore:'M' is deprecated.*:FutureWarning",
+    "ignore:DataFrameGroupBy.apply.*:DeprecationWarning",
 )
-def test_from_and_to_json_roundtrip(syntax_module):
+@pytest.mark.parametrize(("source", "filename"), distributed_examples, ids=id_func)
+def test_from_and_to_json_roundtrip(source, filename) -> None:
     """Tests if the to_json and from_json (and by extension to_dict and from_dict)
     work for all examples in the Example Gallery.
     """
-    for filename in iter_examples_filenames(syntax_module):
-        source = pkgutil.get_data(syntax_module.__name__, filename)
-        chart = eval_block(source)
-
-        if chart is None:
-            raise ValueError(
-                f"Example file {filename} should define chart in its final "
-                "statement."
-            )
-
-        try:
-            first_json = chart.to_json()
-            reconstructed_chart = alt.Chart.from_json(first_json)
-            # As the chart objects are not
-            # necessarily the same - they could use different objects to encode the same
-            # information - we do not test for equality of the chart objects, but rather
-            # for equality of the json strings.
-            second_json = reconstructed_chart.to_json()
-            assert first_json == second_json
-        except Exception as err:
-            raise AssertionError(
-                f"Example file {filename} raised an exception when "
-                f"doing a json conversion roundtrip: {err}"
-            ) from err
-
-
-@pytest.mark.parametrize("engine", ["vl-convert"])
-@pytest.mark.parametrize(
-    "syntax_module", [examples_arguments_syntax, examples_methods_syntax]
+    chart = eval_block(source)
+    if chart is None:
+        msg = f"Example file {filename} should define chart in its final statement."
+        raise ValueError(msg)
+    try:
+        first_json = chart.to_json()
+        reconstructed_chart = alt.Chart.from_json(first_json)
+        # As the chart objects are not
+        # necessarily the same - they could use different objects to encode the same
+        # information - we do not test for equality of the chart objects, but rather
+        # for equality of the json strings.
+        second_json = reconstructed_chart.to_json()
+        assert first_json == second_json
+    except Exception as err:
+        msg = (
+            f"Example file {filename} raised an exception when "
+            f"doing a json conversion roundtrip: {err}"
+        )
+        raise AssertionError(msg) from err
+
+
+@pytest.mark.filterwarnings(
+    "ignore:'M' is deprecated.*:FutureWarning",
+    "ignore:DataFrameGroupBy.apply.*:DeprecationWarning",
+)
+@pytest.mark.parametrize(("source", "filename"), distributed_examples, ids=id_func)
+@pytest.mark.skipif(
+    not VL_CONVERT_AVAILABLE,
+    reason="vl_convert not importable; cannot run mimebundle tests",
 )
-def test_render_examples_to_png(engine, syntax_module):
-    for filename in iter_examples_filenames(syntax_module):
-        if engine == "vl-convert" and vlc is None:
-            pytest.skip("vl_convert not importable; cannot run mimebundle tests")
-
-        source = pkgutil.get_data(syntax_module.__name__, filename)
-        chart = eval_block(source)
-        out = io.BytesIO()
-        chart.save(out, format="png", engine=engine)
-        assert out.getvalue().startswith(b"\x89PNG")
+def test_render_examples_to_png(source, filename) -> None:
+    chart = eval_block(source)
+    if chart is None:
+        msg = f"Example file {filename} should define chart in its final statement."
+        raise ValueError(msg)
+    out = io.BytesIO()
+    chart.save(out, format="png", engine="vl-convert")
+    assert out.getvalue().startswith(b"\x89PNG")
diff --git a/tests/test_jupyter_chart.py b/tests/test_jupyter_chart.py
index ba23f5cf0..999b0e56d 100644
--- a/tests/test_jupyter_chart.py
+++ b/tests/test_jupyter_chart.py
@@ -25,6 +25,7 @@
     transformers = ["default"]
 
 
+@pytest.mark.filterwarnings("ignore:Deprecated in traitlets 4.1.*:DeprecationWarning")
 @pytest.mark.parametrize("transformer", transformers)
 def test_chart_with_no_interactivity(transformer):
     if not has_anywidget:
@@ -54,6 +55,7 @@ def test_chart_with_no_interactivity(transformer):
         assert len(widget.params.trait_values()) == 0
 
 
+@pytest.mark.filterwarnings("ignore:Deprecated in traitlets 4.1.*:DeprecationWarning")
 @pytest.mark.parametrize("transformer", transformers)
 def test_interval_selection_example(transformer):
     if not has_anywidget:
@@ -125,6 +127,7 @@ def test_interval_selection_example(transformer):
         assert selection.store == store
 
 
+@pytest.mark.filterwarnings("ignore:Deprecated in traitlets 4.1.*:DeprecationWarning")
 @pytest.mark.parametrize("transformer", transformers)
 def test_index_selection_example(transformer):
     if not has_anywidget:
@@ -188,6 +191,7 @@ def test_index_selection_example(transformer):
         assert selection.store == store
 
 
+@pytest.mark.filterwarnings("ignore:Deprecated in traitlets 4.1.*:DeprecationWarning")
 @pytest.mark.parametrize("transformer", transformers)
 def test_point_selection(transformer):
     if not has_anywidget:
@@ -254,6 +258,7 @@ def test_point_selection(transformer):
         assert selection.store == store
 
 
+@pytest.mark.filterwarnings("ignore:Deprecated in traitlets 4.1.*:DeprecationWarning")
 @pytest.mark.parametrize("transformer", transformers)
 def test_param_updates(transformer):
     if not has_anywidget:
diff --git a/tests/test_magics.py b/tests/test_magics.py
index 4dd69ba7b..11b7f7d57 100644
--- a/tests/test_magics.py
+++ b/tests/test_magics.py
@@ -7,7 +7,6 @@
     IPYTHON_AVAILABLE = True
 except ImportError:
     IPYTHON_AVAILABLE = False
-    pass
 
 from altair.vegalite.v5 import VegaLite
 
@@ -27,11 +26,11 @@
     _ipshell = InteractiveShell.instance()
     _ipshell.run_cell("%load_ext altair")
     _ipshell.run_cell(
-        """
+        f"""
 import pandas as pd
-table = pd.DataFrame.from_records({})
+table = pd.DataFrame.from_records({DATA_RECORDS})
 the_data = table
-""".format(DATA_RECORDS)
+"""
     )
 
 
@@ -51,14 +50,14 @@
 def test_vegalite_magic_data_included():
     result = _ipshell.run_cell("%%vegalite\n" + json.dumps(VEGALITE_SPEC))
     assert isinstance(result.result, VegaLite)
-    assert VEGALITE_SPEC == result.result.spec
+    assert result.result.spec == VEGALITE_SPEC
 
 
 @pytest.mark.skipif(not IPYTHON_AVAILABLE, reason="requires ipython")
 def test_vegalite_magic_json_flag():
     result = _ipshell.run_cell("%%vegalite --json\n" + json.dumps(VEGALITE_SPEC))
     assert isinstance(result.result, VegaLite)
-    assert VEGALITE_SPEC == result.result.spec
+    assert result.result.spec == VEGALITE_SPEC
 
 
 @pytest.mark.skipif(not IPYTHON_AVAILABLE, reason="requires ipython")
@@ -66,4 +65,4 @@ def test_vegalite_magic_pandas_data():
     spec = {key: val for key, val in VEGALITE_SPEC.items() if key != "data"}
     result = _ipshell.run_cell("%%vegalite table\n" + json.dumps(spec))
     assert isinstance(result.result, VegaLite)
-    assert VEGALITE_SPEC == result.result.spec
+    assert result.result.spec == VEGALITE_SPEC
diff --git a/tests/test_toplevel.py b/tests/test_toplevel.py
index a8b0673e1..9d31c958d 100644
--- a/tests/test_toplevel.py
+++ b/tests/test_toplevel.py
@@ -1,18 +1,10 @@
-import sys
-from os.path import abspath, join, dirname
-
 import altair as alt
 
-current_dir = dirname(__file__)
-sys.path.insert(0, abspath(join(current_dir, "..")))
-from tools import update_init_file  # noqa: E402
+from tools import update_init_file
 
 
 def test_completeness_of__all__():
-    relevant_attributes = [
-        x for x in alt.__dict__ if update_init_file._is_relevant_attribute(x)
-    ]
-    relevant_attributes.sort()
+    relevant_attributes = update_init_file.relevant_attributes(alt.__dict__)
 
     # If the assert statement fails below, there are probably either new objects
     # in the top-level Altair namespace or some were removed.
diff --git a/tests/test_transformed_data.py b/tests/test_transformed_data.py
index 22747563b..d44fb7153 100644
--- a/tests/test_transformed_data.py
+++ b/tests/test_transformed_data.py
@@ -1,4 +1,5 @@
 import pkgutil
+import sys
 
 import pytest
 from vega_datasets import data
@@ -12,7 +13,13 @@
 except ImportError:
     vf = None
 
+XDIST_ENABLED: bool = "xdist" in sys.modules
+"""Use as an `xfail` condition, if running in parallel may cause the test to fail."""
 
+@pytest.mark.filterwarnings(
+    "ignore:'M' is deprecated.*:FutureWarning",
+    "ignore:DataFrameGroupBy.apply.*:DeprecationWarning"
+)
 @pytest.mark.skipif(vf is None, reason="vegafusion not installed")
 # fmt: off
 @pytest.mark.parametrize("filename,rows,cols", [
@@ -101,7 +108,16 @@ def test_primitive_chart_examples(filename, rows, cols, to_reconstruct):
     ("radial_chart.py", [6, 6], [["values"], ["values_start"]]),
     ("scatter_linked_table.py", [392, 14, 14, 14], [["Year"], ["Year"], ["Year"], ["Year"]]),
     ("scatter_marginal_hist.py", [34, 150, 27], [["__count"], ["species"], ["__count"]]),
-    ("scatter_with_layered_histogram.py", [2, 19], [["gender"], ["__count"]]),
+    pytest.param(
+        "scatter_with_layered_histogram.py",
+        [2, 19],
+        [["gender"], ["__count"]],
+        marks=pytest.mark.xfail(
+            XDIST_ENABLED,
+            reason="Possibly `numpy` conflict with `xdist`.\n"
+            "Very intermittent, but only affects `to_reconstruct=False`."
+        ),
+    ),
     ("scatter_with_minimap.py", [1461, 1461], [["date"], ["date"]]),
     ("scatter_with_rolling_mean.py", [1461, 1461], [["date"], ["rolling_mean"]]),
     ("seattle_weather_interactive.py", [1461, 5], [["date"], ["__count"]]),
diff --git a/tests/utils/test_compiler.py b/tests/utils/test_compiler.py
index 4d161804c..79fc5fed1 100644
--- a/tests/utils/test_compiler.py
+++ b/tests/utils/test_compiler.py
@@ -3,12 +3,12 @@
 from altair import vegalite_compilers, Chart
 
 try:
-    import vl_convert as vlc  # noqa: F401
+    import vl_convert as vlc
 except ImportError:
     vlc = None
 
 
-@pytest.fixture
+@pytest.fixture()
 def chart():
     return (
         Chart("cars.json")
diff --git a/tests/utils/test_core.py b/tests/utils/test_core.py
index 27cd3b7ee..4bcdf0e88 100644
--- a/tests/utils/test_core.py
+++ b/tests/utils/test_core.py
@@ -71,7 +71,7 @@ class StrokeWidthValue(ValueChannel, schemapi.SchemaBase):
 
 
 @pytest.mark.parametrize(
-    "value,expected_type",
+    ("value", "expected_type"),
     [
         ([1, 2, 3], "integer"),
         ([1.0, 2.0, 3.0], "floating"),
@@ -164,7 +164,7 @@ def check(s, data, **kwargs):
     check("month(z)", data, timeUnit="month", field="z", type="temporal")
     check("month(t)", data, timeUnit="month", field="t", type="temporal")
 
-    if PANDAS_VERSION >= Version("1.0.0"):
+    if Version("1.0.0") <= PANDAS_VERSION:
         data["b"] = pd.Series([True, False, True, False, None], dtype="boolean")
         check("b", data, field="b", type="nominal")
 
@@ -186,7 +186,7 @@ def test_parse_shorthand_for_arrow_timestamp():
 def test_parse_shorthand_all_aggregates():
     aggregates = alt.Root._schema["definitions"]["AggregateOp"]["enum"]
     for aggregate in aggregates:
-        shorthand = "{aggregate}(field):Q".format(aggregate=aggregate)
+        shorthand = f"{aggregate}(field):Q"
         assert parse_shorthand(shorthand) == {
             "aggregate": aggregate,
             "field": "field",
@@ -201,7 +201,7 @@ def test_parse_shorthand_all_timeunits():
             defn = loc + typ + "TimeUnit"
             timeUnits.extend(alt.Root._schema["definitions"][defn]["enum"])
     for timeUnit in timeUnits:
-        shorthand = "{timeUnit}(field):Q".format(timeUnit=timeUnit)
+        shorthand = f"{timeUnit}(field):Q"
         assert parse_shorthand(shorthand) == {
             "timeUnit": timeUnit,
             "field": "field",
@@ -225,7 +225,7 @@ def test_parse_shorthand_all_window_ops():
     window_ops = alt.Root._schema["definitions"]["WindowOnlyOp"]["enum"]
     aggregates = alt.Root._schema["definitions"]["AggregateOp"]["enum"]
     for op in window_ops + aggregates:
-        shorthand = "{op}(field)".format(op=op)
+        shorthand = f"{op}(field)"
         dct = parse_shorthand(
             shorthand,
             parse_aggregates=False,
@@ -249,7 +249,7 @@ def test_update_nested():
     assert output == output2
 
 
-@pytest.fixture
+@pytest.fixture()
 def channels():
     channels = types.ModuleType("channels")
     exec(FAKE_CHANNELS_MODULE, channels.__dict__)
diff --git a/tests/utils/test_data.py b/tests/utils/test_data.py
index 889e919be..e90474d83 100644
--- a/tests/utils/test_data.py
+++ b/tests/utils/test_data.py
@@ -1,4 +1,5 @@
-import os
+from pathlib import Path
+
 from typing import Any, Callable
 import pytest
 import pandas as pd
@@ -92,7 +93,7 @@ def test_dataframe_to_json():
         filename = result1["url"]
         output = pd.read_json(filename)
     finally:
-        os.remove(filename)
+        Path(filename).unlink()
 
     assert result1 == result2
     assert output.equals(data)
@@ -110,7 +111,7 @@ def test_dict_to_json():
         filename = result1["url"]
         output = pd.read_json(filename).to_dict(orient="records")
     finally:
-        os.remove(filename)
+        Path(filename).unlink()
 
     assert result1 == result2
     assert data == {"values": output}
@@ -128,7 +129,7 @@ def test_dataframe_to_csv():
         filename = result1["url"]
         output = pd.read_csv(filename)
     finally:
-        os.remove(filename)
+        Path(filename).unlink()
 
     assert result1 == result2
     assert output.equals(data)
@@ -146,7 +147,7 @@ def test_dict_to_csv():
         filename = result1["url"]
         output = pd.read_csv(filename).to_dict(orient="records")
     finally:
-        os.remove(filename)
+        Path(filename).unlink()
 
     assert result1 == result2
     assert data == {"values": output}
diff --git a/tests/utils/test_dataframe_interchange.py b/tests/utils/test_dataframe_interchange.py
index b5b69c6db..56e6499ff 100644
--- a/tests/utils/test_dataframe_interchange.py
+++ b/tests/utils/test_dataframe_interchange.py
@@ -1,8 +1,8 @@
 from datetime import datetime
+from pathlib import Path
 import pandas as pd
 import pytest
 import sys
-import os
 
 try:
     import pyarrow as pa
@@ -19,8 +19,7 @@ def windows_has_tzdata():
     This is the default location where tz.cpp will look for (until we make
     this configurable at run-time)
     """
-    tzdata_path = os.path.expandvars(r"%USERPROFILE%\Downloads\tzdata")
-    return os.path.exists(tzdata_path)
+    return Path.home().joinpath("Downloads", "tzdata").exists()
 
 
 # Skip test on Windows when the tz database is not configured.
@@ -55,7 +54,7 @@ def test_duration_raises():
     df = pd.DataFrame(td).reset_index()
     df.columns = ["id", "timedelta"]
     pa_table = pa.table(df)
-    with pytest.raises(ValueError) as e:
+    with pytest.raises(ValueError) as e:  # noqa: PT011
         to_values(pa_table)
 
     # Check that exception mentions the duration[ns] type,
diff --git a/tests/utils/test_html.py b/tests/utils/test_html.py
index ccd41745c..faee7b4c8 100644
--- a/tests/utils/test_html.py
+++ b/tests/utils/test_html.py
@@ -3,7 +3,7 @@
 from altair.utils.html import spec_to_html
 
 
-@pytest.fixture
+@pytest.fixture()
 def spec():
     return {
         "data": {"url": "data.json"},
@@ -47,6 +47,6 @@ def test_spec_to_html(requirejs, fullhtml, spec):
     else:
         assert "require(" not in html
 
-    assert "vega-lite@{}".format(vegalite_version) in html
-    assert "vega@{}".format(vega_version) in html
-    assert "vega-embed@{}".format(vegaembed_version) in html
+    assert f"vega-lite@{vegalite_version}" in html
+    assert f"vega@{vega_version}" in html
+    assert f"vega-embed@{vegaembed_version}" in html
diff --git a/tests/utils/test_mimebundle.py b/tests/utils/test_mimebundle.py
index 6e2965647..a7ab352b0 100644
--- a/tests/utils/test_mimebundle.py
+++ b/tests/utils/test_mimebundle.py
@@ -5,7 +5,7 @@
 from altair.utils.mimebundle import spec_to_mimebundle
 
 try:
-    import vl_convert as vlc  # noqa: F401
+    import vl_convert as vlc
 except ImportError:
     vlc = None
 
@@ -15,7 +15,7 @@
     vf = None
 
 
-@pytest.fixture
+@pytest.fixture()
 def vegalite_spec():
     return {
         "$schema": "https://vega.github.io/schema/vega-lite/v5.json",
@@ -41,7 +41,7 @@ def vegalite_spec():
     }
 
 
-@pytest.fixture
+@pytest.fixture()
 def vega_spec():
     return {
         "$schema": "https://vega.github.io/schema/vega/v5.json",
@@ -197,7 +197,7 @@ def test_spec_to_vegalite_mimebundle(vegalite_spec):
 
 def test_spec_to_vega_mimebundle(vega_spec):
     # ValueError: mode must be 'vega-lite'
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError):  # noqa: PT011
         spec_to_mimebundle(
             spec=vega_spec,
             mode="vega",
diff --git a/tests/utils/test_schemapi.py b/tests/utils/test_schemapi.py
index e1d0e5cc3..9cc201c6b 100644
--- a/tests/utils/test_schemapi.py
+++ b/tests/utils/test_schemapi.py
@@ -146,18 +146,14 @@ class InvalidProperties(_TestSchema):
 class Draft4Schema(_TestSchema):
     _schema = {
         **_validation_selection_schema,
-        **{
-            "$schema": "http://json-schema.org/draft-04/schema#",
-        },
+        "$schema": "http://json-schema.org/draft-04/schema#",
     }
 
 
 class Draft6Schema(_TestSchema):
     _schema = {
         **_validation_selection_schema,
-        **{
-            "$schema": "http://json-schema.org/draft-06/schema#",
-        },
+        "$schema": "http://json-schema.org/draft-06/schema#",
     }
 
 
@@ -291,7 +287,7 @@ def test_schema_validator_selection():
         Draft6Schema.from_dict(dct)
 
 
-@pytest.fixture
+@pytest.fixture()
 def dct():
     return {
         "a": {"foo": "bar"},
@@ -375,7 +371,7 @@ def test_class_with_no_schema():
     class BadSchema(SchemaBase):
         pass
 
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         BadSchema(4)
     assert str(err.value).startswith("Cannot instantiate object")
 
@@ -649,7 +645,7 @@ def chart_error_example__four_errors():
 
 
 @pytest.mark.parametrize(
-    "chart_func, expected_error_message",
+    ("chart_func", "expected_error_message"),
     [
         (
             chart_error_example__invalid_y_option_value_unknown_x_option,
diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py
index 9cf5bda37..cb02a0369 100644
--- a/tests/utils/test_utils.py
+++ b/tests/utils/test_utils.py
@@ -1,5 +1,6 @@
 import io
 import json
+import sys
 import warnings
 
 import numpy as np
@@ -38,6 +39,7 @@ def _check(arr, typ):
             _check([], "nominal")
 
 
+@pytest.mark.filterwarnings("ignore:'H' is deprecated.*:FutureWarning")
 def test_sanitize_dataframe():
     # create a dataframe with various types
     df = pd.DataFrame(
@@ -89,6 +91,7 @@ def test_sanitize_dataframe():
     assert df.equals(df2)
 
 
+@pytest.mark.filterwarnings("ignore:'H' is deprecated.*:FutureWarning")
 @pytest.mark.skipif(pa is None, reason="pyarrow not installed")
 def test_sanitize_dataframe_arrow_columns():
     # create a dataframe with various types
@@ -120,8 +123,12 @@ def test_sanitize_dataframe_arrow_columns():
     json.dumps(records)
 
 
+@pytest.mark.filterwarnings("ignore:'H' is deprecated.*:FutureWarning")
 @pytest.mark.skipif(pa is None, reason="pyarrow not installed")
-def test_sanitize_pyarrow_table_columns():
+@pytest.mark.xfail(
+    sys.platform == "win32", reason="Timezone database is not installed on Windows"
+)
+def test_sanitize_pyarrow_table_columns() -> None:
     # create a dataframe with various types
     df = pd.DataFrame(
         {
@@ -176,14 +183,14 @@ def test_sanitize_dataframe_colnames():
 
     # Test that non-string columns result in an error
     df.columns = [4, "foo", "bar"]
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         sanitize_dataframe(df)
     assert str(err.value).startswith("Dataframe contains invalid column name: 4.")
 
 
 def test_sanitize_dataframe_timedelta():
     df = pd.DataFrame({"r": pd.timedelta_range(start="1 day", periods=4)})
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         sanitize_dataframe(df)
     assert str(err.value).startswith('Field "r" has type "timedelta')
 
@@ -197,7 +204,7 @@ def test_sanitize_dataframe_infs():
 
 @pytest.mark.skipif(
     not hasattr(pd, "Int64Dtype"),
-    reason="Nullable integers not supported in pandas v{}".format(pd.__version__),
+    reason=f"Nullable integers not supported in pandas v{pd.__version__}",
 )
 def test_sanitize_nullable_integers():
     df = pd.DataFrame(
@@ -227,7 +234,7 @@ def test_sanitize_nullable_integers():
 
 @pytest.mark.skipif(
     not hasattr(pd, "StringDtype"),
-    reason="dedicated String dtype not supported in pandas v{}".format(pd.__version__),
+    reason=f"dedicated String dtype not supported in pandas v{pd.__version__}",
 )
 def test_sanitize_string_dtype():
     df = pd.DataFrame(
@@ -253,7 +260,7 @@ def test_sanitize_string_dtype():
 
 @pytest.mark.skipif(
     not hasattr(pd, "BooleanDtype"),
-    reason="Nullable boolean dtype not supported in pandas v{}".format(pd.__version__),
+    reason=f"Nullable boolean dtype not supported in pandas v{pd.__version__}",
 )
 def test_sanitize_boolean_dtype():
     df = pd.DataFrame(
diff --git a/tests/vegalite/test_common.py b/tests/vegalite/test_common.py
index 0cc216e68..ca99e942a 100644
--- a/tests/vegalite/test_common.py
+++ b/tests/vegalite/test_common.py
@@ -7,7 +7,7 @@
 from altair.vegalite import v5
 
 
-@pytest.fixture
+@pytest.fixture()
 def basic_spec():
     return {
         "data": {"url": "data.csv"},
@@ -93,7 +93,7 @@ def test_max_rows(alt):
 
     with alt.data_transformers.enable("default"):
         basic_chart.to_dict()  # this should not fail
-
-    with alt.data_transformers.enable("default", max_rows=5):
-        with pytest.raises(alt.MaxRowsError):
-            basic_chart.to_dict()  # this should not fail
+    with alt.data_transformers.enable("default", max_rows=5), pytest.raises(
+        alt.MaxRowsError
+    ):
+        basic_chart.to_dict()  # this should not fail
diff --git a/tests/vegalite/v5/test_alias.py b/tests/vegalite/v5/test_alias.py
index f39ab57cc..eab6e10c9 100644
--- a/tests/vegalite/v5/test_alias.py
+++ b/tests/vegalite/v5/test_alias.py
@@ -10,7 +10,8 @@ def test_aliases():
         try:
             getattr(alt, alias)
         except AttributeError as err:
-            raise AssertionError(f"cannot resolve '{alias}':, {err}") from err
+            msg = f"cannot resolve '{alias}':, {err}"
+            raise AssertionError(msg) from err
 
         # this test fails if the alias match a colliding name in core
         with pytest.raises(AttributeError):
diff --git a/tests/vegalite/v5/test_api.py b/tests/vegalite/v5/test_api.py
index bda7dd9bb..556bda631 100644
--- a/tests/vegalite/v5/test_api.py
+++ b/tests/vegalite/v5/test_api.py
@@ -14,7 +14,7 @@
 import altair.vegalite.v5 as alt
 
 try:
-    import vl_convert as vlc  # noqa: F401
+    import vl_convert as vlc
 except ImportError:
     vlc = None
 
@@ -48,7 +48,7 @@ def _make_chart_type(chart_type):
         )
     )
 
-    if chart_type in ["layer", "hconcat", "vconcat", "concat"]:
+    if chart_type in {"layer", "hconcat", "vconcat", "concat"}:
         func = getattr(alt, chart_type)
         return func(base.mark_square(), base.mark_circle())
     elif chart_type == "facet":
@@ -60,10 +60,11 @@ def _make_chart_type(chart_type):
     elif chart_type == "chart":
         return base
     else:
-        raise ValueError("chart_type='{}' is not recognized".format(chart_type))
+        msg = f"chart_type='{chart_type}' is not recognized"
+        raise ValueError(msg)
 
 
-@pytest.fixture
+@pytest.fixture()
 def basic_chart():
     data = pd.DataFrame(
         {
@@ -112,6 +113,7 @@ def Chart(data):
     assert dct["data"] == {"name": "Foo"}
 
 
+@pytest.mark.filterwarnings("ignore:'Y' is deprecated.*:FutureWarning")
 def test_chart_infer_types():
     data = pd.DataFrame(
         {
@@ -189,7 +191,7 @@ def _check_encodings(chart):
 
 
 @pytest.mark.parametrize(
-    "args, kwargs",
+    ("args", "kwargs"),
     [
         getargs(detail=["value:Q", "name:N"], tooltip=["value:Q", "name:N"]),
         getargs(detail=["value", "name"], tooltip=["value", "name"]),
@@ -217,6 +219,7 @@ def test_multiple_encodings(args, kwargs):
     assert dct["encoding"]["tooltip"] == encoding_dct
 
 
+@pytest.mark.filterwarnings("ignore:'Y' is deprecated.*:FutureWarning")
 def test_chart_operations():
     data = pd.DataFrame(
         {
@@ -278,7 +281,7 @@ def test_selection_expression():
     assert selection.value.to_dict() == {"expr": f"{selection.name}.value"}
 
     assert isinstance(selection["value"], alt.expr.Expression)
-    assert selection["value"].to_dict() == "{0}['value']".format(selection.name)
+    assert selection["value"].to_dict() == f"{selection.name}['value']"
 
     magic_attr = "__magic__"
     with pytest.raises(AttributeError):
@@ -288,25 +291,24 @@ def test_selection_expression():
 @pytest.mark.parametrize("format", ["html", "json", "png", "svg", "pdf", "bogus"])
 @pytest.mark.parametrize("engine", ["vl-convert"])
 def test_save(format, engine, basic_chart):
-    if format in ["pdf", "png"]:
+    if format in {"pdf", "png"}:
         out = io.BytesIO()
         mode = "rb"
     else:
         out = io.StringIO()
         mode = "r"
 
-    if format in ["svg", "png", "pdf", "bogus"]:
-        if engine == "vl-convert":
-            if format == "bogus":
-                with pytest.raises(ValueError) as err:
-                    basic_chart.save(out, format=format, engine=engine)
-                assert f"Unsupported format: '{format}'" in str(err.value)
-                return
-            elif vlc is None:
-                with pytest.raises(ValueError) as err:
-                    basic_chart.save(out, format=format, engine=engine)
-                assert "vl-convert-python" in str(err.value)
-                return
+    if format in {"svg", "png", "pdf", "bogus"} and engine == "vl-convert":
+        if format == "bogus":
+            with pytest.raises(ValueError) as err:  # noqa: PT011
+                basic_chart.save(out, format=format, engine=engine)
+            assert f"Unsupported format: '{format}'" in str(err.value)
+            return
+        elif vlc is None:
+            with pytest.raises(ValueError) as err:  # noqa: PT011
+                basic_chart.save(out, format=format, engine=engine)
+            assert "vl-convert-python" in str(err.value)
+            return
 
     basic_chart.save(out, format=format, engine=engine)
     out.seek(0)
@@ -330,10 +332,10 @@ def test_save(format, engine, basic_chart):
     for fp in [filename, pathlib.Path(filename)]:
         try:
             basic_chart.save(fp, format=format, engine=engine)
-            with open(fp, mode) as f:
+            with pathlib.Path(fp).open(mode) as f:
                 assert f.read()[:1000] == content[:1000]
         finally:
-            os.remove(fp)
+            pathlib.Path(fp).unlink()
 
 
 @pytest.mark.parametrize("inline", [False, True])
@@ -480,9 +482,9 @@ def test_selection():
     assert isinstance(single & multi, alt.SelectionPredicateComposition)
     assert isinstance(single | multi, alt.SelectionPredicateComposition)
     assert isinstance(~single, alt.SelectionPredicateComposition)
-    assert "and" in (single & multi).to_dict().keys()
-    assert "or" in (single | multi).to_dict().keys()
-    assert "not" in (~single).to_dict().keys()
+    assert "and" in (single & multi).to_dict()
+    assert "or" in (single | multi).to_dict()
+    assert "not" in (~single).to_dict()
 
     # test that default names increment (regression for #1454)
     sel1 = alt.selection_point()
@@ -605,9 +607,10 @@ def test_transforms():
 
     # kwargs don't maintain order in Python < 3.6, so window list can
     # be reversed
-    assert chart.transform == [
-        alt.WindowTransform(frame=[None, 0], window=window)
-    ] or chart.transform == [alt.WindowTransform(frame=[None, 0], window=window[::-1])]
+    assert chart.transform in (
+        [alt.WindowTransform(frame=[None, 0], window=window)],
+        [alt.WindowTransform(frame=[None, 0], window=window[::-1])],
+    )
 
 
 def test_filter_transform_selection_predicates():
@@ -829,7 +832,7 @@ def test_consolidate_InlineData():
     with alt.data_transformers.enable(consolidate_datasets=True):
         dct = chart.to_dict()
     assert dct["data"]["format"] == data.format
-    assert list(dct["datasets"].values())[0] == data.values
+    assert next(iter(dct["datasets"].values())) == data.values
 
     data = alt.InlineData(values=[], name="runtime_data")
     chart = alt.Chart(data).mark_point()
@@ -952,34 +955,34 @@ def test_layer_errors():
 
     simple_chart = alt.Chart("data.txt").mark_point()
 
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         toplevel_chart + simple_chart
     assert str(err.value).startswith(
         'Objects with "config" attribute cannot be used within LayerChart.'
     )
 
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         alt.hconcat(simple_chart) + simple_chart
     assert (
         str(err.value)
         == "Concatenated charts cannot be layered. Instead, layer the charts before concatenating."
     )
 
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         repeat_chart + simple_chart
     assert (
         str(err.value)
         == "Repeat charts cannot be layered. Instead, layer the charts before repeating."
     )
 
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         facet_chart1 + simple_chart
     assert (
         str(err.value)
         == "Faceted charts cannot be layered. Instead, layer the charts before faceting."
     )
 
-    with pytest.raises(ValueError) as err:
+    with pytest.raises(ValueError) as err:  # noqa: PT011
         alt.layer(simple_chart) + facet_chart2
     assert (
         str(err.value)
diff --git a/tests/vegalite/v5/test_data.py b/tests/vegalite/v5/test_data.py
index 2cf48e833..a2af707fa 100644
--- a/tests/vegalite/v5/test_data.py
+++ b/tests/vegalite/v5/test_data.py
@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
 
 import pandas as pd
 import pytest
@@ -6,7 +6,7 @@
 from altair.vegalite.v5 import data as alt
 
 
-@pytest.fixture
+@pytest.fixture()
 def sample_data():
     return pd.DataFrame({"x": range(10), "y": range(10)})
 
@@ -22,12 +22,13 @@ def test_disable_max_rows(sample_data):
             alt.data_transformers.get()(sample_data)
 
     try:
-        with alt.data_transformers.enable("json"):
-            # Ensure that there is no TypeError for non-max_rows transformers.
-            with alt.data_transformers.disable_max_rows():
-                jsonfile = alt.data_transformers.get()(sample_data)
+        # Ensure that there is no TypeError for non-max_rows transformers.
+        with alt.data_transformers.enable(
+            "json"
+        ), alt.data_transformers.disable_max_rows():
+            jsonfile = alt.data_transformers.get()(sample_data)
     except TypeError:
         jsonfile = {}
     finally:
         if jsonfile:
-            os.remove(jsonfile["url"])
+            Path(jsonfile["url"]).unlink()
diff --git a/tests/vegalite/v5/test_display.py b/tests/vegalite/v5/test_display.py
index 2a3fa3a35..636d05402 100644
--- a/tests/vegalite/v5/test_display.py
+++ b/tests/vegalite/v5/test_display.py
@@ -32,11 +32,10 @@ def test_check_renderer_options():
         display(None)
 
     # check that an error is appropriately raised if the test fails
-    with pytest.raises(AssertionError):
-        with check_render_options(foo="bar"):
-            from IPython.display import display
+    with pytest.raises(AssertionError), check_render_options(foo="bar"):  # noqa: PT012
+        from IPython.display import display
 
-            display(None)
+        display(None)
 
 
 def test_display_options():
diff --git a/tests/vegalite/v5/test_params.py b/tests/vegalite/v5/test_params.py
index 91d299283..d9f61b8c9 100644
--- a/tests/vegalite/v5/test_params.py
+++ b/tests/vegalite/v5/test_params.py
@@ -105,15 +105,15 @@ def test_parameter_naming():
     assert prm.param.name == "some_name"
 
     # test automatic naming which has the form such as param_5
-    prm0, prm1, prm2 = [alt.param() for _ in range(3)]
+    prm0, prm1, prm2 = (alt.param() for _ in range(3))
 
     res = re.match("param_([0-9]+)", prm0.param.name)
 
     assert res
 
     num = int(res[1])
-    assert prm1.param.name == f"param_{num+1}"
-    assert prm2.param.name == f"param_{num+2}"
+    assert prm1.param.name == f"param_{num + 1}"
+    assert prm2.param.name == f"param_{num + 2}"
 
 
 def test_selection_expression():
diff --git a/tests/vegalite/v5/test_renderers.py b/tests/vegalite/v5/test_renderers.py
index b06706e34..a20de1503 100644
--- a/tests/vegalite/v5/test_renderers.py
+++ b/tests/vegalite/v5/test_renderers.py
@@ -8,18 +8,18 @@
 
 
 try:
-    import vl_convert as vlc  # noqa: F401
+    import vl_convert as vlc
 except ImportError:
     vlc = None
 
 try:
-    import anywidget  # noqa: F401
+    import anywidget
 
 except ImportError:
     anywidget = None  # type: ignore
 
 
-@pytest.fixture
+@pytest.fixture()
 def chart():
     return alt.Chart("data.csv").mark_point()
 
@@ -95,7 +95,8 @@ def test_renderer_with_none_embed_options(chart, renderer="mimetype"):
         assert bundle["image/svg+xml"].startswith("<svg")
 
 
-def test_jupyter_renderer_mimetype(chart, renderer="jupyter"):
+@pytest.mark.filterwarnings("ignore:Deprecated in traitlets 4.1.*:DeprecationWarning")
+def test_jupyter_renderer_mimetype(chart, renderer="jupyter") -> None:
     """Test that we get the expected widget mimetype when the jupyter renderer is enabled"""
     if not anywidget:
         pytest.skip("anywidget not importable; skipping test")
diff --git a/tests/vegalite/v5/test_theme.py b/tests/vegalite/v5/test_theme.py
index 0eab5546d..64bb9cf28 100644
--- a/tests/vegalite/v5/test_theme.py
+++ b/tests/vegalite/v5/test_theme.py
@@ -4,7 +4,7 @@
 from altair.vegalite.v5.theme import VEGA_THEMES
 
 
-@pytest.fixture
+@pytest.fixture()
 def chart():
     return alt.Chart("data.csv").mark_bar().encode(x="x:Q")
 
diff --git a/tools/__init__.py b/tools/__init__.py
new file mode 100644
index 000000000..09251b2a1
--- /dev/null
+++ b/tools/__init__.py
@@ -0,0 +1,8 @@
+from tools import schemapi, generate_api_docs, generate_schema_wrapper, update_init_file
+
+__all__ = [
+    "generate_api_docs",
+    "generate_schema_wrapper",
+    "schemapi",
+    "update_init_file",
+]
diff --git a/tools/generate_api_docs.py b/tools/generate_api_docs.py
index d6bc0482e..2f923d8c2 100644
--- a/tools/generate_api_docs.py
+++ b/tools/generate_api_docs.py
@@ -3,18 +3,15 @@
 based on the updated Altair schema.
 """
 
-import sys
+from __future__ import annotations
+from pathlib import Path
 import types
-from os.path import abspath, dirname, join
-from typing import Final, Optional, Iterator, List
+from typing import Final, Iterator
 from types import ModuleType
 
-# Import Altair from head
-ROOT_DIR = abspath(join(dirname(__file__), ".."))
-sys.path.insert(0, ROOT_DIR)
-import altair as alt  # noqa: E402
+import altair as alt
 
-API_FILENAME: Final = join(ROOT_DIR, "doc", "user_guide", "api.rst")
+API_FILENAME: Final = str(Path.cwd() / "doc" / "user_guide" / "api.rst")
 
 API_TEMPLATE: Final = """\
 .. _api:
@@ -73,32 +70,31 @@
 def iter_objects(
     mod: ModuleType,
     ignore_private: bool = True,
-    restrict_to_type: Optional[type] = None,
-    restrict_to_subclass: Optional[type] = None,
+    restrict_to_type: type | None = None,
+    restrict_to_subclass: type | None = None,
 ) -> Iterator[str]:
     for name in dir(mod):
         obj = getattr(mod, name)
-        if ignore_private:
-            if name.startswith("_"):
-                continue
-        if restrict_to_type is not None:
-            if not isinstance(obj, restrict_to_type):
-                continue
-        if restrict_to_subclass is not None:
-            if not (isinstance(obj, type) and issubclass(obj, restrict_to_subclass)):
-                continue
+        if ignore_private and name.startswith("_"):
+            continue
+        if restrict_to_type is not None and not isinstance(obj, restrict_to_type):
+            continue
+        if restrict_to_subclass is not None and (
+            not (isinstance(obj, type) and issubclass(obj, restrict_to_subclass))
+        ):
+            continue
         yield name
 
 
-def toplevel_charts() -> List[str]:
+def toplevel_charts() -> list[str]:
     return sorted(iter_objects(alt.api, restrict_to_subclass=alt.TopLevelMixin))  # type: ignore[attr-defined]
 
 
-def encoding_wrappers() -> List[str]:
+def encoding_wrappers() -> list[str]:
     return sorted(iter_objects(alt.channels, restrict_to_subclass=alt.SchemaBase))
 
 
-def api_functions() -> List[str]:
+def api_functions() -> list[str]:
     # Exclude typing.cast
     altair_api_functions = [
         obj_name
@@ -108,29 +104,29 @@ def api_functions() -> List[str]:
     return sorted(altair_api_functions)
 
 
-def lowlevel_wrappers() -> List[str]:
+def lowlevel_wrappers() -> list[str]:
     objects = sorted(iter_objects(alt.schema.core, restrict_to_subclass=alt.SchemaBase))  # type: ignore[attr-defined]
     # The names of these two classes are also used for classes in alt.channels. Due to
     # how imports are set up, these channel classes overwrite the two low-level classes
     # in the top-level Altair namespace. Therefore, they cannot be imported as e.g.
     # altair.Color (which gives you the Channel class) and therefore Sphinx won't
     # be able to produce a documentation page.
-    objects = [o for o in objects if o not in ("Color", "Text")]
+    objects = [o for o in objects if o not in {"Color", "Text"}]
     return objects
 
 
 def write_api_file() -> None:
-    print("Updating API docs\n  ->{}".format(API_FILENAME))
+    print(f"Updating API docs\n  ->{API_FILENAME}")
     sep = "\n   "
-    with open(API_FILENAME, "w") as f:
-        f.write(
-            API_TEMPLATE.format(
-                toplevel_charts=sep.join(toplevel_charts()),
-                api_functions=sep.join(api_functions()),
-                encoding_wrappers=sep.join(encoding_wrappers()),
-                lowlevel_wrappers=sep.join(lowlevel_wrappers()),
-            )
-        )
+    Path(API_FILENAME).write_text(
+        API_TEMPLATE.format(
+            toplevel_charts=sep.join(toplevel_charts()),
+            api_functions=sep.join(api_functions()),
+            encoding_wrappers=sep.join(encoding_wrappers()),
+            lowlevel_wrappers=sep.join(lowlevel_wrappers()),
+        ),
+        encoding="utf-8",
+    )
 
 
 if __name__ == "__main__":
diff --git a/tools/generate_schema_wrapper.py b/tools/generate_schema_wrapper.py
index 40958c202..b9f4ef18d 100644
--- a/tools/generate_schema_wrapper.py
+++ b/tools/generate_schema_wrapper.py
@@ -1,47 +1,41 @@
 """Generate a schema wrapper from a schema"""
 
+from __future__ import annotations
 import argparse
 import copy
 import json
-import os
+from pathlib import Path
 import re
 import sys
 import textwrap
 from dataclasses import dataclass
-from os.path import abspath, dirname, join
-from typing import Dict, Final, List, Literal, Optional, Tuple, Type, Union
+from typing import Final, Iterable, Literal
 from urllib import request
-
 import m2r
 
-# Add path so that schemapi can be imported from the tools folder
-current_dir = dirname(__file__)
-sys.path.insert(0, abspath(current_dir))
-# And another path so that Altair can be imported from head. This is relevant when
-# generate_api_docs is imported in the main function
-sys.path.insert(0, abspath(join(current_dir, "..")))
-from schemapi import codegen  # noqa: E402
-from schemapi.codegen import CodeSnippet  # noqa: E402
-from schemapi.utils import (  # noqa: E402
-    SchemaInfo,
+sys.path.insert(0, str(Path.cwd()))
+from tools.schemapi import codegen, CodeSnippet, SchemaInfo
+from tools.schemapi.utils import (
     get_valid_identifier,
     resolve_references,
-    ruff_format_str,
+    ruff_format_py,
     rst_syntax_for_class,
     indent_docstring,
+    ruff_write_lint_format_str,
 )
 
+
 SCHEMA_VERSION: Final = "v5.17.0"
 
-reLink = re.compile(r"(?<=\[)([^\]]+)(?=\]\([^\)]+\))", re.M)
-reSpecial = re.compile(r"[*_]{2,3}|`", re.M)
+reLink = re.compile(r"(?<=\[)([^\]]+)(?=\]\([^\)]+\))", re.MULTILINE)
+reSpecial = re.compile(r"[*_]{2,3}|`", re.MULTILINE)
 
 HEADER: Final = """\
 # The contents of this file are automatically written by
 # tools/generate_schema_wrapper.py. Do not modify directly.
 """
 
-SCHEMA_URL_TEMPLATE: Final = "https://vega.github.io/schema/" "{library}/{version}.json"
+SCHEMA_URL_TEMPLATE: Final = "https://vega.github.io/schema/{library}/{version}.json"
 
 CHANNEL_MYPY_IGNORE_STATEMENTS: Final = """\
 # These errors need to be ignored as they come from the overload methods
@@ -53,39 +47,15 @@
 # mypy: disable-error-code="no-overload-impl, empty-body, misc"
 """
 
-PARAMETER_PROTOCOL: Final = """
-class _Parameter(Protocol):
-    # This protocol represents a Parameter as defined in api.py
-    # It would be better if we could directly use the Parameter class,
-    # but that would create a circular import.
-    # The protocol does not need to have all the attributes and methods of this
-    # class but the actual api.Parameter just needs to pass a type check
-    # as a core._Parameter.
-
-    _counter: int
-
-    def _get_name(cls) -> str:
-        ...
-
-    def to_dict(self) -> TypingDict[str, Union[str, dict]]:
-        ...
-
-    def _to_expr(self) -> str:
-        ...
-"""
-
 BASE_SCHEMA: Final = """
 class {basename}(SchemaBase):
     _rootschema = load_schema()
     @classmethod
-    def _default_wrapper_classes(cls) -> TypingGenerator[type, None, None]:
+    def _default_wrapper_classes(cls) -> Iterator[type[Any]]:
         return _subclasses({basename})
 """
 
 LOAD_SCHEMA: Final = '''
-import pkgutil
-import json
-
 def load_schema() -> dict:
     """Load the json schema associated with this module's functions"""
     schema_bytes = pkgutil.get_data(__name__, "{schemafile}")
@@ -102,19 +72,17 @@ class FieldChannelMixin:
     def to_dict(
         self,
         validate: bool = True,
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
-    ) -> Union[dict, List[dict]]:
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> dict | list[dict]:
         context = context or {}
         ignore = ignore or []
         shorthand = self._get("shorthand")  # type: ignore[attr-defined]
         field = self._get("field")  # type: ignore[attr-defined]
 
         if shorthand is not Undefined and field is not Undefined:
-            raise ValueError(
-                "{} specifies both shorthand={} and field={}. "
-                "".format(self.__class__.__name__, shorthand, field)
-            )
+            msg = f"{self.__class__.__name__} specifies both shorthand={shorthand} and field={field}. "
+            raise ValueError(msg)
 
         if isinstance(shorthand, (tuple, list)):
             # If given a list of shorthands, then transform it to a list of classes
@@ -140,21 +108,20 @@ def to_dict(
                 parsed.pop("type", None)
             elif not (type_in_shorthand or type_defined_explicitly):
                 if isinstance(context.get("data", None), pd.DataFrame):
-                    raise ValueError(
-                        'Unable to determine data type for the field "{}";'
+                    msg = (
+                        f'Unable to determine data type for the field "{shorthand}";'
                         " verify that the field name is not misspelled."
                         " If you are referencing a field from a transform,"
-                        " also confirm that the data type is specified correctly.".format(
-                            shorthand
-                        )
+                        " also confirm that the data type is specified correctly."
                     )
+                    raise ValueError(msg)
                 else:
-                    raise ValueError(
-                        "{} encoding field is specified without a type; "
+                    msg = (
+                        f"{shorthand} encoding field is specified without a type; "
                         "the type cannot be automatically inferred because "
                         "the data is not specified as a pandas.DataFrame."
-                        "".format(shorthand)
                     )
+                    raise ValueError(msg)
         else:
             # Shorthand is not a string; we pass the definition to field,
             # and do not do any parsing.
@@ -170,8 +137,8 @@ class ValueChannelMixin:
     def to_dict(
         self,
         validate: bool = True,
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict:
         context = context or {}
         ignore = ignore or []
@@ -193,16 +160,13 @@ class DatumChannelMixin:
     def to_dict(
         self,
         validate: bool = True,
-        ignore: Optional[List[str]] = None,
-        context: Optional[TypingDict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> dict:
         context = context or {}
         ignore = ignore or []
-        datum = self._get("datum", Undefined)  # type: ignore[attr-defined]
+        datum = self._get("datum", Undefined)  # type: ignore[attr-defined] # noqa
         copy = self  # don't copy unless we need to
-        if datum is not Undefined:
-            if isinstance(datum, core.SchemaBase):
-                pass
         return super(DatumChannelMixin, copy).to_dict(
             validate=validate, ignore=ignore, context=context
         )
@@ -257,7 +221,8 @@ class {classname}({basename}):
     '''
     )
 
-    def _process_description(self, description: str) -> str:
+    @staticmethod
+    def _process_description(description: str) -> str:
         return process_description(description)
 
 
@@ -277,6 +242,10 @@ def process_description(description: str) -> str:
     description = description.replace(">`_", ">`__")
     # Some entries in the Vega-Lite schema miss the second occurence of '__'
     description = description.replace("__Default value: ", "__Default value:__ ")
+    # Fixing ambiguous unicode, RUF001 produces RUF002 in docs
+    description = description.replace("’", "'")  # noqa: RUF001 [RIGHT SINGLE QUOTATION MARK]
+    description = description.replace("–", "-")  # noqa: RUF001 [EN DASH]
+    description = description.replace(" ", " ")  # noqa: RUF001 [NO-BREAK SPACE]
     description += "\n"
     return description.strip()
 
@@ -338,21 +307,22 @@ def schema_url(version: str = SCHEMA_VERSION) -> str:
 
 
 def download_schemafile(
-    version: str, schemapath: str, skip_download: bool = False
-) -> str:
+    version: str, schemapath: Path, skip_download: bool = False
+) -> Path:
     url = schema_url(version=version)
-    if not os.path.exists(schemapath):
-        os.makedirs(schemapath)
-    filename = os.path.join(schemapath, "vega-lite-schema.json")
+    schemadir = Path(schemapath)
+    schemadir.mkdir(parents=True, exist_ok=True)
+    fp = schemadir / "vega-lite-schema.json"
     if not skip_download:
-        request.urlretrieve(url, filename)
-    elif not os.path.exists(filename):
-        raise ValueError("Cannot skip download: {} does not exist".format(filename))
-    return filename
+        request.urlretrieve(url, fp)
+    elif not fp.exists():
+        msg = f"Cannot skip download: {fp!s} does not exist"
+        raise ValueError(msg)
+    return fp
 
 
-def load_schema_with_shorthand_properties(schemapath: str) -> dict:
-    with open(schemapath, encoding="utf8") as f:
+def load_schema_with_shorthand_properties(schemapath: Path) -> dict:
+    with schemapath.open(encoding="utf8") as f:
         schema = json.load(f)
 
     schema = _add_shorthand_property_to_field_encodings(schema)
@@ -383,9 +353,8 @@ def _add_shorthand_property_to_field_encodings(schema: dict) -> dict:
             }
             if "required" not in defschema:
                 defschema["required"] = ["shorthand"]
-            else:
-                if "shorthand" not in defschema["required"]:
-                    defschema["required"].append("shorthand")
+            elif "shorthand" not in defschema["required"]:
+                defschema["required"].append("shorthand")
             schema["definitions"][field_ref.split("/")[-1]] = defschema
     return schema
 
@@ -395,16 +364,17 @@ def copy_schemapi_util() -> None:
     Copy the schemapi utility into altair/utils/ and its test file to tests/utils/
     """
     # copy the schemapi utility file
-    source_path = abspath(join(dirname(__file__), "schemapi", "schemapi.py"))
-    destination_path = abspath(
-        join(dirname(__file__), "..", "altair", "utils", "schemapi.py")
-    )
+    source_fp = Path(__file__).parent / "schemapi" / "schemapi.py"
+    destination_fp = Path(__file__).parent / ".." / "altair" / "utils" / "schemapi.py"
 
-    print("Copying\n {}\n  -> {}".format(source_path, destination_path))
-    with open(source_path, "r", encoding="utf8") as source:
-        with open(destination_path, "w", encoding="utf8") as dest:
-            dest.write(HEADER)
-            dest.writelines(source.readlines())
+    print(f"Copying\n {source_fp!s}\n  -> {destination_fp!s}")
+    with source_fp.open(encoding="utf8") as source, destination_fp.open(
+        "w", encoding="utf8"
+    ) as dest:
+        dest.write(HEADER)
+        dest.writelines(source.readlines())
+    if sys.platform == "win32":
+        ruff_format_py(destination_fp)
 
 
 def recursive_dict_update(schema: dict, root: dict, def_dict: dict) -> None:
@@ -413,7 +383,7 @@ def recursive_dict_update(schema: dict, root: dict, def_dict: dict) -> None:
         if "properties" in next_schema:
             definition = schema["$ref"]
             properties = next_schema["properties"]
-            for k in def_dict.keys():
+            for k in def_dict:
                 if k in properties:
                     def_dict[k] = definition
         else:
@@ -423,21 +393,22 @@ def recursive_dict_update(schema: dict, root: dict, def_dict: dict) -> None:
             recursive_dict_update(sub_schema, root, def_dict)
 
 
-def get_field_datum_value_defs(propschema: SchemaInfo, root: dict) -> dict:
-    def_dict: Dict[str, Optional[str]] = {k: None for k in ("field", "datum", "value")}
+def get_field_datum_value_defs(propschema: SchemaInfo, root: dict) -> dict[str, str]:
+    def_dict: dict[str, str | None] = dict.fromkeys(("field", "datum", "value"))
     schema = propschema.schema
     if propschema.is_reference() and "properties" in schema:
         if "field" in schema["properties"]:
             def_dict["field"] = propschema.ref
         else:
-            raise ValueError("Unexpected schema structure")
+            msg = "Unexpected schema structure"
+            raise ValueError(msg)
     else:
         recursive_dict_update(schema, root, def_dict)
 
     return {i: j for i, j in def_dict.items() if j}
 
 
-def toposort(graph: Dict[str, List[str]]) -> List[str]:
+def toposort(graph: dict[str, list[str]]) -> list[str]:
     """Topological sort of a directed acyclic graph.
 
     Parameters
@@ -453,8 +424,8 @@ def toposort(graph: Dict[str, List[str]]) -> List[str]:
     """
     # Once we drop support for Python 3.8, this can potentially be replaced
     # with graphlib.TopologicalSorter from the standard library.
-    stack: List[str] = []
-    visited: Dict[str, Literal[True]] = {}
+    stack: list[str] = []
+    visited: dict[str, Literal[True]] = {}
 
     def visit(nodes):
         for node in sorted(nodes, reverse=True):
@@ -467,14 +438,14 @@ def visit(nodes):
     return stack
 
 
-def generate_vegalite_schema_wrapper(schema_file: str) -> str:
+def generate_vegalite_schema_wrapper(schema_file: Path) -> str:
     """Generate a schema wrapper at the given path."""
     # TODO: generate simple tests for each wrapper
     basename = "VegaLiteSchema"
 
     rootschema = load_schema_with_shorthand_properties(schema_file)
 
-    definitions: Dict[str, SchemaGenerator] = {}
+    definitions: dict[str, SchemaGenerator] = {}
 
     for name in rootschema["definitions"]:
         defschema = {"$ref": "#/definitions/" + name}
@@ -486,10 +457,10 @@ def generate_vegalite_schema_wrapper(schema_file: str) -> str:
             schemarepr=defschema_repr,
             rootschema=rootschema,
             basename=basename,
-            rootschemarepr=CodeSnippet("{}._rootschema".format(basename)),
+            rootschemarepr=CodeSnippet(f"{basename}._rootschema"),
         )
 
-    graph: Dict[str, List[str]] = {}
+    graph: dict[str, list[str]] = {}
 
     for name, schema in definitions.items():
         graph[name] = []
@@ -507,34 +478,31 @@ def generate_vegalite_schema_wrapper(schema_file: str) -> str:
     # of exported classes which are also defined in the channels module which takes
     # precedent in the generated __init__.py file one level up where core.py
     # and channels.py are imported. Importing both confuses type checkers.
-    all_ = [
-        c for c in definitions if not c.startswith("_") and c not in ("Color", "Text")
-    ] + [
-        "Root",
-        "VegaLiteSchema",
-        "SchemaBase",
-        "load_schema",
-    ]
+    it = (c for c in definitions.keys() - {"Color", "Text"} if not c.startswith("_"))
+    all_ = [*sorted(it), "Root", "VegaLiteSchema", "SchemaBase", "load_schema"]
 
     contents = [
         HEADER,
-        "__all__ = {}".format(all_),
-        "from typing import Any, Literal, Union, Protocol, Sequence, List",
-        "from typing import Dict as TypingDict",
-        "from typing import Generator as TypingGenerator" "",
-        "from altair.utils.schemapi import SchemaBase, Undefined, UndefinedType, _subclasses",
+        "from __future__ import annotations\n"
+        "from typing import Any, Literal, Union, Protocol, Sequence, List, Iterator, TYPE_CHECKING",
+        "import pkgutil",
+        "import json\n",
+        "from altair.utils.schemapi import SchemaBase, Undefined, UndefinedType, _subclasses # noqa: F401\n",
+        _type_checking_only_imports(
+            "from altair import Parameter",
+            "from altair.utils.schemapi import Optional",
+            "from ._typing import * # noqa: F403",
+        ),
+        "\n" f"__all__ = {all_}\n",
         LOAD_SCHEMA.format(schemafile="vega-lite-schema.json"),
-    ]
-    contents.append(PARAMETER_PROTOCOL)
-    contents.append(BASE_SCHEMA.format(basename=basename))
-    contents.append(
+        BASE_SCHEMA.format(basename=basename),
         schema_class(
             "Root",
             schema=rootschema,
             basename=basename,
-            schemarepr=CodeSnippet("{}._rootschema".format(basename)),
-        )
-    )
+            schemarepr=CodeSnippet(f"{basename}._rootschema"),
+        ),
+    ]
 
     for name in toposort(graph):
         contents.append(definitions[name].schema_class())
@@ -543,36 +511,49 @@ def generate_vegalite_schema_wrapper(schema_file: str) -> str:
     return "\n".join(contents)
 
 
+def _type_checking_only_imports(*imports: str) -> str:
+    return (
+        "\n# ruff: noqa: F405\nif TYPE_CHECKING:\n"
+        + "\n".join(f"    {s}" for s in imports)
+        + "\n"
+    )
+
+
 @dataclass
 class ChannelInfo:
     supports_arrays: bool
     deep_description: str
-    field_class_name: Optional[str] = None
-    datum_class_name: Optional[str] = None
-    value_class_name: Optional[str] = None
+    field_class_name: str | None = None
+    datum_class_name: str | None = None
+    value_class_name: str | None = None
 
 
 def generate_vegalite_channel_wrappers(
-    schemafile: str, version: str, imports: Optional[List[str]] = None
+    schemafile: Path, version: str, imports: list[str] | None = None
 ) -> str:
     # TODO: generate __all__ for top of file
     schema = load_schema_with_shorthand_properties(schemafile)
-    if imports is None:
-        imports = [
-            "import sys",
-            "from . import core",
-            "import pandas as pd",
-            "from altair.utils.schemapi import Undefined, UndefinedType, with_property_setters",
-            "from altair.utils import parse_shorthand",
-            "from typing import Any, overload, Sequence, List, Literal, Union, Optional",
-            "from typing import Dict as TypingDict",
-        ]
-    contents = [HEADER]
-    contents.append(CHANNEL_MYPY_IGNORE_STATEMENTS)
-    contents.extend(imports)
-    contents.append("")
 
-    contents.append(CHANNEL_MIXINS)
+    imports = imports or [
+        "from __future__ import annotations\n",
+        "import sys",
+        "from . import core",
+        "import pandas as pd",
+        "from altair.utils.schemapi import Undefined, UndefinedType, with_property_setters",
+        "from altair.utils import parse_shorthand",
+        "from typing import Any, overload, Sequence, List, Literal, Union, TYPE_CHECKING",
+    ]
+    contents = [
+        HEADER,
+        CHANNEL_MYPY_IGNORE_STATEMENTS,
+        *imports,
+        _type_checking_only_imports(
+            "from altair import Parameter, SchemaBase # noqa: F401",
+            "from altair.utils.schemapi import Optional # noqa: F401",
+            "from ._typing import * # noqa: F403",
+        ),
+        CHANNEL_MIXINS,
+    ]
 
     encoding_def = "FacetedEncoding"
 
@@ -593,16 +574,16 @@ def generate_vegalite_channel_wrappers(
 
         for encoding_spec, definition in def_dict.items():
             classname = prop[0].upper() + prop[1:]
-            basename = definition.split("/")[-1]
+            basename = definition.rsplit("/", maxsplit=1)[-1]
             basename = get_valid_identifier(basename)
 
             defschema = {"$ref": definition}
 
-            Generator: Union[
-                Type[FieldSchemaGenerator],
-                Type[DatumSchemaGenerator],
-                Type[ValueSchemaGenerator],
-            ]
+            Generator: (
+                type[FieldSchemaGenerator]
+                | type[DatumSchemaGenerator]
+                | type[ValueSchemaGenerator]
+            )
             if encoding_spec == "field":
                 Generator = FieldSchemaGenerator
                 nodefault = []
@@ -641,9 +622,9 @@ def generate_vegalite_channel_wrappers(
 
 
 def generate_vegalite_mark_mixin(
-    schemafile: str, markdefs: Dict[str, str]
-) -> Tuple[List[str], str]:
-    with open(schemafile, encoding="utf8") as f:
+    schemafile: Path, markdefs: dict[str, str]
+) -> tuple[list[str], str]:
+    with schemafile.open(encoding="utf8") as f:
         schema = json.load(f)
 
     class_name = "MarkMethodMixin"
@@ -665,7 +646,7 @@ def generate_vegalite_mark_mixin(
             marks = schema["definitions"][mark_enum]["enum"]
         else:
             marks = [schema["definitions"][mark_enum]["const"]]
-        info = SchemaInfo({"$ref": "#/definitions/" + mark_def}, rootschema=schema)
+        info = SchemaInfo({"$ref": f"#/definitions/{mark_def}"}, rootschema=schema)
 
         # adapted from SchemaInfo.init_code
         arg_info = codegen.get_args(info)
@@ -676,15 +657,13 @@ def generate_vegalite_mark_mixin(
             f"{p}: "
             + info.properties[p].get_python_type_representation(
                 for_type_hints=True,
-                altair_classes_prefix="core",
                 additional_type_hints=["UndefinedType"],
             )
             + " = Undefined"
             for p in (sorted(arg_info.required) + sorted(arg_info.kwds))
         ]
         dict_args = [
-            "{0}={0}".format(p)
-            for p in (sorted(arg_info.required) + sorted(arg_info.kwds))
+            f"{p}={p}" for p in (sorted(arg_info.required) + sorted(arg_info.kwds))
         ]
 
         if arg_info.additional or arg_info.invalid_kwds:
@@ -704,8 +683,11 @@ def generate_vegalite_mark_mixin(
     return imports, "\n".join(code)
 
 
-def generate_vegalite_config_mixin(schemafile: str) -> Tuple[List[str], str]:
-    imports = ["from . import core", "from altair.utils import use_signature"]
+def generate_vegalite_config_mixin(schemafile: Path) -> tuple[list[str], str]:
+    imports = [
+        "from . import core",
+        "from altair.utils import use_signature",
+    ]
 
     class_name = "ConfigMethodMixin"
 
@@ -713,7 +695,7 @@ def generate_vegalite_config_mixin(schemafile: str) -> Tuple[List[str], str]:
         f"class {class_name}:",
         '    """A mixin class that defines config methods"""',
     ]
-    with open(schemafile, encoding="utf8") as f:
+    with schemafile.open(encoding="utf8") as f:
         schema = json.load(f)
     info = SchemaInfo({"$ref": "#/definitions/Config"}, rootschema=schema)
 
@@ -732,10 +714,9 @@ def generate_vegalite_config_mixin(schemafile: str) -> Tuple[List[str], str]:
 
 def vegalite_main(skip_download: bool = False) -> None:
     version = SCHEMA_VERSION
-    path = abspath(
-        join(dirname(__file__), "..", "altair", "vegalite", version.split(".")[0])
-    )
-    schemapath = os.path.join(path, "schema")
+    vn = version.split(".")[0]
+    fp = (Path(__file__).parent / ".." / "altair" / "vegalite" / vn).resolve()
+    schemapath = fp / "schema"
     schemafile = download_schemafile(
         version=version,
         schemapath=schemapath,
@@ -743,35 +724,32 @@ def vegalite_main(skip_download: bool = False) -> None:
     )
 
     # Generate __init__.py file
-    outfile = join(schemapath, "__init__.py")
-    print("Writing {}".format(outfile))
+    outfile = schemapath / "__init__.py"
+    print(f"Writing {outfile!s}")
     content = [
         "# ruff: noqa\n",
         "from .core import *\nfrom .channels import *\n",
         f"SCHEMA_VERSION = '{version}'\n",
-        "SCHEMA_URL = {!r}\n" "".format(schema_url(version)),
+        f"SCHEMA_URL = {schema_url(version)!r}\n",
     ]
-    with open(outfile, "w", encoding="utf8") as f:
-        f.write(ruff_format_str(content))
+    ruff_write_lint_format_str(outfile, content)
+
+    files: dict[Path, str | Iterable[str]] = {}
 
     # Generate the core schema wrappers
-    outfile = join(schemapath, "core.py")
-    print("Generating\n {}\n  ->{}".format(schemafile, outfile))
-    file_contents = generate_vegalite_schema_wrapper(schemafile)
-    with open(outfile, "w", encoding="utf8") as f:
-        f.write(ruff_format_str(file_contents))
+    fp_core = schemapath / "core.py"
+    print(f"Generating\n {schemafile!s}\n  ->{fp_core!s}")
+    files[fp_core] = generate_vegalite_schema_wrapper(schemafile)
 
     # Generate the channel wrappers
-    outfile = join(schemapath, "channels.py")
-    print("Generating\n {}\n  ->{}".format(schemafile, outfile))
-    code = generate_vegalite_channel_wrappers(schemafile, version=version)
-    with open(outfile, "w", encoding="utf8") as f:
-        f.write(ruff_format_str(code))
+    fp_channels = schemapath / "channels.py"
+    print(f"Generating\n {schemafile!s}\n  ->{fp_channels!s}")
+    files[fp_channels] = generate_vegalite_channel_wrappers(schemafile, version=version)
 
     # generate the mark mixin
-    markdefs = {k: k + "Def" for k in ["Mark", "BoxPlot", "ErrorBar", "ErrorBand"]}
-    outfile = join(schemapath, "mixins.py")
-    print("Generating\n {}\n  ->{}".format(schemafile, outfile))
+    markdefs = {k: f"{k}Def" for k in ["Mark", "BoxPlot", "ErrorBar", "ErrorBand"]}
+    fp_mixins = schemapath / "mixins.py"
+    print(f"Generating\n {schemafile!s}\n  ->{fp_mixins!s}")
     mark_imports, mark_mixin = generate_vegalite_mark_mixin(schemafile, markdefs)
     config_imports, config_mixin = generate_vegalite_config_mixin(schemafile)
     try_except_imports = [
@@ -780,26 +758,45 @@ def vegalite_main(skip_download: bool = False) -> None:
         "else:",
         "    from typing_extensions import Self",
     ]
-    stdlib_imports = ["import sys"]
-    imports = sorted(set(mark_imports + config_imports))
-    content = [
+    stdlib_imports = ["from __future__ import annotations\n", "import sys"]
+    content_mixins = [
         HEADER,
         "\n".join(stdlib_imports),
         "\n\n",
-        "\n".join(imports),
+        "\n".join(sorted({*mark_imports, *config_imports})),
         "\n\n",
         "\n".join(try_except_imports),
+        "\n\n",
+        _type_checking_only_imports(
+            "from altair import Parameter, SchemaBase",
+            "from altair.utils.schemapi import Optional",
+            "from ._typing import * # noqa: F403",
+        ),
         "\n\n\n",
         mark_mixin,
         "\n\n\n",
         config_mixin,
     ]
-    with open(outfile, "w", encoding="utf8") as f:
-        f.write(ruff_format_str(content))
+    files[fp_mixins] = content_mixins
+
+    # Write `_typing.py` TypeAlias, for import in generated modules
+    from tools.schemapi.utils import TypeAliasTracer
+
+    fp_typing = schemapath / "_typing.py"
+    msg = (
+        f"Generating\n {schemafile!s}\n  ->{fp_typing!s}\n"
+        f"Tracer cache collected {TypeAliasTracer.n_entries!r} entries."
+    )
+    print(msg)
+    TypeAliasTracer.write_module(fp_typing, header=HEADER)
+    # Write the pre-generated modules
+    for fp, contents in files.items():
+        print(f"Writing\n {schemafile!s}\n  ->{fp!s}")
+        ruff_write_lint_format_str(fp, contents)
 
 
 def _create_encode_signature(
-    channel_infos: Dict[str, ChannelInfo],
+    channel_infos: dict[str, ChannelInfo],
 ) -> str:
     signature_args: list[str] = ["self"]
     docstring_parameters: list[str] = ["", "Parameters", "----------", ""]
@@ -828,16 +825,20 @@ def _create_encode_signature(
             union_types.append("list")
             docstring_union_types.append("List")
 
-        union_types = union_types + datum_and_value_class_names + ["UndefinedType"]
+        union_types = union_types + datum_and_value_class_names
         docstring_union_types = docstring_union_types + [
             rst_syntax_for_class(c) for c in datum_and_value_class_names
         ]
 
-        signature_args.append(f"{channel}: Union[{', '.join(union_types)}] = Undefined")
+        signature_args.append(
+            f"{channel}: Optional[Union[{', '.join(union_types)}]] = Undefined"
+        )
 
-        docstring_parameters.append(f"{channel} : {', '.join(docstring_union_types)}")
-        docstring_parameters.append(
-            "    {}".format(process_description(info.deep_description))
+        docstring_parameters.extend(
+            (
+                f"{channel} : {', '.join(docstring_union_types)}",
+                f"    {process_description(info.deep_description)}",
+            )
         )
     if len(docstring_parameters) > 1:
         docstring_parameters += [""]
@@ -862,8 +863,7 @@ def main() -> None:
 
     # The modules below are imported after the generation of the new schema files
     # as these modules import Altair. This allows them to use the new changes
-    import generate_api_docs  # noqa: E402
-    import update_init_file  # noqa: E402
+    from tools import generate_api_docs, update_init_file
 
     generate_api_docs.write_api_file()
     update_init_file.update__all__variable()
diff --git a/tools/schemapi/__init__.py b/tools/schemapi/__init__.py
index f287ad3fb..58b90a73f 100644
--- a/tools/schemapi/__init__.py
+++ b/tools/schemapi/__init__.py
@@ -2,8 +2,9 @@
 schemapi: tools for generating Python APIs from JSON schemas
 """
 
-from .schemapi import SchemaBase, Undefined
-from .utils import SchemaInfo
+from tools.schemapi.schemapi import SchemaBase, Undefined
+from tools.schemapi.utils import SchemaInfo
+from tools.schemapi import codegen, utils
+from tools.schemapi.codegen import CodeSnippet
 
-
-__all__ = ("SchemaBase", "Undefined", "SchemaInfo")
+__all__ = ["CodeSnippet", "SchemaBase", "SchemaInfo", "Undefined", "codegen", "utils"]
diff --git a/tools/schemapi/codegen.py b/tools/schemapi/codegen.py
index 63e89d647..ee41bfcaf 100644
--- a/tools/schemapi/codegen.py
+++ b/tools/schemapi/codegen.py
@@ -1,8 +1,9 @@
 """Code generation utilities"""
 
+from __future__ import annotations
 import re
 import textwrap
-from typing import Set, Final, Optional, List, Union, Dict, Tuple
+from typing import Final
 from dataclasses import dataclass
 
 from .utils import (
@@ -27,9 +28,9 @@ def __repr__(self) -> str:
 @dataclass
 class ArgInfo:
     nonkeyword: bool
-    required: Set[str]
-    kwds: Set[str]
-    invalid_kwds: Set[str]
+    required: set[str]
+    kwds: set[str]
+    invalid_kwds: set[str]
     additional: bool
 
 
@@ -37,9 +38,9 @@ def get_args(info: SchemaInfo) -> ArgInfo:
     """Return the list of args & kwds for building the __init__ function"""
     # TODO: - set additional properties correctly
     #       - handle patternProperties etc.
-    required: Set[str] = set()
-    kwds: Set[str] = set()
-    invalid_kwds: Set[str] = set()
+    required: set[str] = set()
+    kwds: set[str] = set()
+    invalid_kwds: set[str] = set()
 
     # TODO: specialize for anyOf/oneOf?
 
@@ -69,7 +70,8 @@ def get_args(info: SchemaInfo) -> ArgInfo:
         additional = True
         # additional = info.additionalProperties or info.patternProperties
     else:
-        raise ValueError("Schema object not understood")
+        msg = "Schema object not understood"
+        raise ValueError(msg)
 
     return ArgInfo(
         nonkeyword=nonkeyword,
@@ -131,13 +133,13 @@ def __init__(
         self,
         classname: str,
         schema: dict,
-        rootschema: Optional[dict] = None,
-        basename: Union[str, List[str]] = "SchemaBase",
-        schemarepr: Optional[object] = None,
-        rootschemarepr: Optional[object] = None,
-        nodefault: Optional[List[str]] = None,
+        rootschema: dict | None = None,
+        basename: str | list[str] = "SchemaBase",
+        schemarepr: object | None = None,
+        rootschemarepr: object | None = None,
+        nodefault: list[str] | None = None,
         haspropsetters: bool = False,
-        altair_classes_prefix: Optional[str] = None,
+        altair_classes_prefix: str | None = None,
         **kwargs,
     ) -> None:
         self.classname = classname
@@ -151,7 +153,7 @@ def __init__(
         self.kwargs = kwargs
         self.altair_classes_prefix = altair_classes_prefix
 
-    def subclasses(self) -> List[str]:
+    def subclasses(self) -> list[str]:
         """Return a list of subclass names, if any."""
         info = SchemaInfo(self.schema, self.rootschema)
         return [child.refname for child in info.anyOf if child.is_reference()]
@@ -196,7 +198,7 @@ def arg_info(self) -> ArgInfo:
     def docstring(self, indent: int = 0) -> str:
         info = self.info
         doc = [
-            "{} schema wrapper".format(self.classname),
+            f"{self.classname} schema wrapper",
         ]
         if info.description:
             doc += self._process_description(  # remove condition description
@@ -224,9 +226,7 @@ def docstring(self, indent: int = 0) -> str:
                             altair_classes_prefix=self.altair_classes_prefix,
                         ),
                     ),
-                    "    {}".format(
-                        self._process_description(propinfo.deep_description)
-                    ),
+                    f"    {self._process_description(propinfo.deep_description)}",
                 ]
         if len(doc) > 1:
             doc += [""]
@@ -246,8 +246,8 @@ def init_code(self, indent: int = 0) -> str:
         return initfunc
 
     def init_args(
-        self, additional_types: Optional[List[str]] = None
-    ) -> Tuple[List[str], List[str]]:
+        self, additional_types: list[str] | None = None
+    ) -> tuple[list[str], list[str]]:
         additional_types = additional_types or []
         info = self.info
         arg_info = self.arg_info
@@ -256,8 +256,8 @@ def init_args(
         arg_info.required -= nodefault
         arg_info.kwds -= nodefault
 
-        args: List[str] = ["self"]
-        super_args: List[str] = []
+        args: list[str] = ["self"]
+        super_args: list[str] = []
 
         self.init_kwds = sorted(arg_info.kwds)
 
@@ -268,7 +268,7 @@ def init_args(
             super_args.append("*args")
 
         args.extend(
-            f"{p}: Union["
+            f"{p}: Optional[Union["
             + ", ".join(
                 [
                     *additional_types,
@@ -277,14 +277,13 @@ def init_args(
                         altair_classes_prefix=self.altair_classes_prefix,
                         return_as_str=False,
                     ),
-                    "UndefinedType",
                 ]
             )
-            + "] = Undefined"
+            + "]] = Undefined"
             for p in sorted(arg_info.required) + sorted(arg_info.kwds)
         )
         super_args.extend(
-            "{0}={0}".format(p)
+            f"{p}={p}"
             for p in sorted(nodefault)
             + sorted(arg_info.required)
             + sorted(arg_info.kwds)
@@ -295,9 +294,9 @@ def init_args(
             super_args.append("**kwds")
         return args, super_args
 
-    def get_args(self, si: SchemaInfo) -> List[str]:
+    def get_args(self, si: SchemaInfo) -> list[str]:
         contents = ["self"]
-        prop_infos: Dict[str, SchemaInfo] = {}
+        prop_infos: dict[str, SchemaInfo] = {}
         if si.is_anyOf():
             prop_infos = {}
             for si_sub in si.anyOf:
@@ -345,16 +344,17 @@ def get_args(self, si: SchemaInfo) -> List[str]:
 
     def get_signature(
         self, attr: str, sub_si: SchemaInfo, indent: int, has_overload: bool = False
-    ) -> List[str]:
+    ) -> list[str]:
         lines = []
         if has_overload:
             lines.append("@overload")
         args = ", ".join(self.get_args(sub_si))
-        lines.append(f"def {attr}({args}) -> '{self.classname}':")
-        lines.append(indent * " " + "...\n")
+        lines.extend(
+            (f"def {attr}({args}) -> '{self.classname}':", indent * " " + "...\n")
+        )
         return lines
 
-    def setter_hint(self, attr: str, indent: int) -> List[str]:
+    def setter_hint(self, attr: str, indent: int) -> list[str]:
         si = SchemaInfo(self.schema, self.rootschema).properties[attr]
         if si.is_anyOf():
             return self._get_signature_any_of(si, attr, indent)
@@ -363,7 +363,7 @@ def setter_hint(self, attr: str, indent: int) -> List[str]:
 
     def _get_signature_any_of(
         self, si: SchemaInfo, attr: str, indent: int
-    ) -> List[str]:
+    ) -> list[str]:
         signatures = []
         for sub_si in si.anyOf:
             if sub_si.is_anyOf():
@@ -375,7 +375,7 @@ def _get_signature_any_of(
                 )
         return list(flatten(signatures))
 
-    def method_code(self, indent: int = 0) -> Optional[str]:
+    def method_code(self, indent: int = 0) -> str | None:
         """Return code to assist setter methods"""
         if not self.haspropsetters:
             return None
diff --git a/tools/schemapi/schemapi.py b/tools/schemapi/schemapi.py
index ce1268c04..b9c79414b 100644
--- a/tools/schemapi/schemapi.py
+++ b/tools/schemapi/schemapi.py
@@ -1,30 +1,29 @@
-import collections
+from __future__ import annotations
+
 import contextlib
 import copy
 import inspect
 import json
-import sys
 import textwrap
+from collections import defaultdict
+from importlib.metadata import version as importlib_version
+from itertools import chain, zip_longest
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Sequence,
-    List,
-    Dict,
-    Optional,
-    DefaultDict,
-    Tuple,
+    Final,
     Iterable,
-    Type,
-    Generator,
-    Union,
-    overload,
+    Iterator,
     Literal,
+    Sequence,
     TypeVar,
+    Union,
+    overload,
+    List,
+    Dict,
 )
-from itertools import zip_longest
-from importlib.metadata import version as importlib_version
-from typing import Final
-
+from typing_extensions import TypeAlias
+from functools import partial
 import jsonschema
 import jsonschema.exceptions
 import jsonschema.validators
@@ -37,15 +36,27 @@
 # not yet be fully instantiated in case your code is being executed during import time
 from altair import vegalite
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+if TYPE_CHECKING:
+    import sys
+
+    from referencing import Registry
 
-TSchemaBase = TypeVar("TSchemaBase", bound=Type["SchemaBase"])
+    from altair import ChartType
+    from typing import ClassVar
+
+    if sys.version_info >= (3, 13):
+        from typing import TypeIs
+    else:
+        from typing_extensions import TypeIs
+
+    if sys.version_info >= (3, 11):
+        from typing import Self, Never
+    else:
+        from typing_extensions import Self, Never
 
-ValidationErrorList = List[jsonschema.exceptions.ValidationError]
-GroupedValidationErrors = Dict[str, ValidationErrorList]
+
+ValidationErrorList: TypeAlias = List[jsonschema.exceptions.ValidationError]
+GroupedValidationErrors: TypeAlias = Dict[str, ValidationErrorList]
 
 # This URI is arbitrary and could be anything else. It just cannot be an empty
 # string as we need to reference the schema registered in
@@ -83,7 +94,7 @@ def disable_debug_mode() -> None:
 
 
 @contextlib.contextmanager
-def debug_mode(arg: bool) -> Generator[None, None, None]:
+def debug_mode(arg: bool) -> Iterator[None]:
     global DEBUG_MODE
     original = DEBUG_MODE
     DEBUG_MODE = arg
@@ -95,9 +106,9 @@ def debug_mode(arg: bool) -> Generator[None, None, None]:
 
 @overload
 def validate_jsonschema(
-    spec: Dict[str, Any],
-    schema: Dict[str, Any],
-    rootschema: Optional[Dict[str, Any]] = ...,
+    spec: Any,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = ...,
     *,
     raise_error: Literal[True] = ...,
 ) -> None: ...
@@ -105,12 +116,12 @@ def validate_jsonschema(
 
 @overload
 def validate_jsonschema(
-    spec: Dict[str, Any],
-    schema: Dict[str, Any],
-    rootschema: Optional[Dict[str, Any]] = ...,
+    spec: Any,
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = ...,
     *,
     raise_error: Literal[False],
-) -> Optional[jsonschema.exceptions.ValidationError]: ...
+) -> jsonschema.exceptions.ValidationError | None: ...
 
 
 def validate_jsonschema(
@@ -134,7 +145,7 @@ def validate_jsonschema(
 
         # Nothing special about this first error but we need to choose one
         # which can be raised
-        main_error = list(grouped_errors.values())[0][0]
+        main_error = next(iter(grouped_errors.values()))[0]
         # All errors are then attached as a new attribute to ValidationError so that
         # they can be used in SchemaValidationError to craft a more helpful
         # error message. Setting a new attribute like this is not ideal as
@@ -150,9 +161,9 @@ def validate_jsonschema(
 
 
 def _get_errors_from_spec(
-    spec: Dict[str, Any],
-    schema: Dict[str, Any],
-    rootschema: Optional[Dict[str, Any]] = None,
+    spec: dict[str, Any],
+    schema: dict[str, Any],
+    rootschema: dict[str, Any] | None = None,
 ) -> ValidationErrorList:
     """Uses the relevant jsonschema validator to validate the passed in spec
     against the schema using the rootschema to resolve references.
@@ -173,7 +184,7 @@ def _get_errors_from_spec(
     validator_cls = jsonschema.validators.validator_for(
         {"$schema": json_schema_draft_url}
     )
-    validator_kwargs: Dict[str, Any] = {}
+    validator_kwargs: dict[str, Any] = {}
     if hasattr(validator_cls, "FORMAT_CHECKER"):
         validator_kwargs["format_checker"] = validator_cls.FORMAT_CHECKER
 
@@ -196,7 +207,7 @@ def _get_errors_from_spec(
     return errors
 
 
-def _get_json_schema_draft_url(schema: dict) -> str:
+def _get_json_schema_draft_url(schema: dict[str, Any]) -> str:
     return schema.get("$schema", _DEFAULT_JSON_SCHEMA_DRAFT_URL)
 
 
@@ -206,32 +217,34 @@ def _use_referencing_library() -> bool:
     return Version(jsonschema_version_str) >= Version("4.18")
 
 
-def _prepare_references_in_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+def _prepare_references_in_schema(schema: dict[str, Any]) -> dict[str, Any]:
     # Create a copy so that $ref is not modified in the original schema in case
     # that it would still reference a dictionary which might be attached to
     # an Altair class _schema attribute
     schema = copy.deepcopy(schema)
 
-    def _prepare_refs(d: Dict[str, Any]) -> Dict[str, Any]:
-        """Add _VEGA_LITE_ROOT_URI in front of all $ref values. This function
-        recursively iterates through the whole dictionary."""
+    def _prepare_refs(d: dict[str, Any]) -> dict[str, Any]:
+        """Add _VEGA_LITE_ROOT_URI in front of all $ref values.
+
+        This function recursively iterates through the whole dictionary.
+
+        $ref values can only be nested in dictionaries or lists
+        as the passed in `d` dictionary comes from the Vega-Lite json schema
+        and in json we only have arrays (-> lists in Python) and objects
+        (-> dictionaries in Python) which we need to iterate through.
+        """
         for key, value in d.items():
             if key == "$ref":
                 d[key] = _VEGA_LITE_ROOT_URI + d[key]
-            else:
-                # $ref values can only be nested in dictionaries or lists
-                # as the passed in `d` dictionary comes from the Vega-Lite json schema
-                # and in json we only have arrays (-> lists in Python) and objects
-                # (-> dictionaries in Python) which we need to iterate through.
-                if isinstance(value, dict):
-                    d[key] = _prepare_refs(value)
-                elif isinstance(value, list):
-                    prepared_values = []
-                    for v in value:
-                        if isinstance(v, dict):
-                            v = _prepare_refs(v)
-                        prepared_values.append(v)
-                    d[key] = prepared_values
+            elif isinstance(value, dict):
+                d[key] = _prepare_refs(value)
+            elif isinstance(value, list):
+                prepared_values = []
+                for v in value:
+                    if isinstance(v, dict):
+                        v = _prepare_refs(v)
+                    prepared_values.append(v)
+                d[key] = prepared_values
         return d
 
     schema = _prepare_refs(schema)
@@ -241,8 +254,8 @@ def _prepare_refs(d: Dict[str, Any]) -> Dict[str, Any]:
 # We do not annotate the return value here as the referencing library is not always
 # available and this function is only executed in those cases.
 def _get_referencing_registry(
-    rootschema: Dict[str, Any], json_schema_draft_url: Optional[str] = None
-):
+    rootschema: dict[str, Any], json_schema_draft_url: str | None = None
+) -> Registry:
     # Referencing is a dependency of newer jsonschema versions, starting with the
     # version that is specified in _use_referencing_library and we therefore
     # can expect that it is installed if the function returns True.
@@ -286,7 +299,7 @@ def _group_errors_by_json_path(
     a chart specification and can therefore be considered as an identifier of an
     'issue' in the chart that needs to be fixed.
     """
-    errors_by_json_path = collections.defaultdict(list)
+    errors_by_json_path = defaultdict(list)
     for err in errors:
         err_key = getattr(err, "json_path", _json_path(err))
         errors_by_json_path[err_key].append(err)
@@ -354,7 +367,7 @@ def _deduplicate_errors(
         }
         deduplicated_errors: ValidationErrorList = []
         for validator, errors in errors_by_validator.items():
-            deduplication_func = deduplication_functions.get(validator, None)
+            deduplication_func = deduplication_functions.get(validator)
             if deduplication_func is not None:
                 errors = deduplication_func(errors)
             deduplicated_errors.extend(_deduplicate_by_message(errors))
@@ -385,9 +398,7 @@ def _group_errors_by_validator(errors: ValidationErrorList) -> GroupedValidation
     was set although no additional properties are allowed then "validator" is
     `"additionalProperties`, etc.
     """
-    errors_by_validator: DefaultDict[str, ValidationErrorList] = (
-        collections.defaultdict(list)
-    )
+    errors_by_validator: defaultdict[str, ValidationErrorList] = defaultdict(list)
     for err in errors:
         # Ignore mypy error as err.validator as it wrongly sees err.validator
         # as of type Optional[Validator] instead of str which it is according
@@ -453,7 +464,7 @@ def _deduplicate_by_message(errors: ValidationErrorList) -> ValidationErrorList:
     return list({e.message: e for e in errors}.values())
 
 
-def _subclasses(cls: type) -> Generator[type, None, None]:
+def _subclasses(cls: type[Any]) -> Iterator[type[Any]]:
     """Breadth-first sequence of all classes which inherit from cls."""
     seen = set()
     current_set = {cls}
@@ -464,7 +475,7 @@ def _subclasses(cls: type) -> Generator[type, None, None]:
             yield cls
 
 
-def _todict(obj: Any, context: Optional[Dict[str, Any]]) -> Any:
+def _todict(obj: Any, context: dict[str, Any] | None) -> Any:
     """Convert an object to a dict representation."""
     if isinstance(obj, SchemaBase):
         return obj.to_dict(validate=False, context=context)
@@ -483,8 +494,8 @@ def _todict(obj: Any, context: Optional[Dict[str, Any]]) -> Any:
 
 
 def _resolve_references(
-    schema: Dict[str, Any], rootschema: Optional[Dict[str, Any]] = None
-) -> Dict[str, Any]:
+    schema: dict[str, Any], rootschema: dict[str, Any] | None = None
+) -> dict[str, Any]:
     """Resolve schema references until there is no $ref anymore
     in the top-level of the dictionary.
     """
@@ -509,7 +520,7 @@ def _resolve_references(
 class SchemaValidationError(jsonschema.ValidationError):
     """A wrapper for jsonschema.ValidationError with friendlier traceback"""
 
-    def __init__(self, obj: "SchemaBase", err: jsonschema.ValidationError) -> None:
+    def __init__(self, obj: SchemaBase, err: jsonschema.ValidationError) -> None:
         super().__init__(**err._contents())
         self.obj = obj
         self._errors: GroupedValidationErrors = getattr(
@@ -524,14 +535,14 @@ def __str__(self) -> str:
 
     def _get_message(self) -> str:
         def indent_second_line_onwards(message: str, indent: int = 4) -> str:
-            modified_lines: List[str] = []
+            modified_lines: list[str] = []
             for idx, line in enumerate(message.split("\n")):
                 if idx > 0 and len(line) > 0:
                     line = " " * indent + line
                 modified_lines.append(line)
             return "\n".join(modified_lines)
 
-        error_messages: List[str] = []
+        error_messages: list[str] = []
         # Only show a maximum of 3 errors as else the final message returned by this
         # method could get very long.
         for errors in list(self._errors.values())[:3]:
@@ -586,7 +597,7 @@ def _get_additional_properties_error_message(
 
     def _get_altair_class_for_error(
         self, error: jsonschema.exceptions.ValidationError
-    ) -> Type["SchemaBase"]:
+    ) -> type[SchemaBase]:
         """Try to get the lowest class possible in the chart hierarchy so
         it can be displayed in the error message. This should lead to more informative
         error messages pointing the user closer to the source of the issue.
@@ -608,13 +619,13 @@ def _get_altair_class_for_error(
     @staticmethod
     def _format_params_as_table(param_dict_keys: Iterable[str]) -> str:
         """Format param names into a table so that they are easier to read"""
-        param_names: Tuple[str, ...]
-        name_lengths: Tuple[int, ...]
+        param_names: tuple[str, ...]
+        name_lengths: tuple[int, ...]
         param_names, name_lengths = zip(
             *[
                 (name, len(name))
                 for name in param_dict_keys
-                if name not in ["kwds", "self"]
+                if name not in {"kwds", "self"}
             ]
         )
         # Worst case scenario with the same longest param name in the same
@@ -627,24 +638,24 @@ def _format_params_as_table(param_dict_keys: Iterable[str]) -> str:
         columns = min(max_column_width // max_name_length, square_columns)
 
         # Compute roughly equal column heights to evenly divide the param names
-        def split_into_equal_parts(n: int, p: int) -> List[int]:
+        def split_into_equal_parts(n: int, p: int) -> list[int]:
             return [n // p + 1] * (n % p) + [n // p] * (p - n % p)
 
         column_heights = split_into_equal_parts(num_param_names, columns)
 
         # Section the param names into columns and compute their widths
-        param_names_columns: List[Tuple[str, ...]] = []
-        column_max_widths: List[int] = []
+        param_names_columns: list[tuple[str, ...]] = []
+        column_max_widths: list[int] = []
         last_end_idx: int = 0
         for ch in column_heights:
             param_names_columns.append(param_names[last_end_idx : last_end_idx + ch])
             column_max_widths.append(
-                max([len(param_name) for param_name in param_names_columns[-1]])
+                max(len(param_name) for param_name in param_names_columns[-1])
             )
             last_end_idx = ch + last_end_idx
 
         # Transpose the param name columns into rows to facilitate looping
-        param_names_rows: List[Tuple[str, ...]] = []
+        param_names_rows: list[tuple[str, ...]] = []
         for li in zip_longest(*param_names_columns, fillvalue=""):
             param_names_rows.append(li)
         # Build the table as a string by iterating over and formatting the rows
@@ -666,7 +677,7 @@ def _get_default_error_message(
         self,
         errors: ValidationErrorList,
     ) -> str:
-        bullet_points: List[str] = []
+        bullet_points: list[str] = []
         errors_by_validator = _group_errors_by_validator(errors)
         if "enum" in errors_by_validator:
             for error in errors_by_validator["enum"]:
@@ -710,7 +721,7 @@ def _get_default_error_message(
         # considered so far. This is not expected to be used but more exists
         # as a fallback for cases which were not known during development.
         for validator, errors in errors_by_validator.items():
-            if validator not in ("enum", "type"):
+            if validator not in {"enum", "type"}:
                 message += "\n".join([e.message for e in errors])
 
         return message
@@ -721,16 +732,28 @@ class UndefinedType:
 
     __instance = None
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args, **kwargs) -> Self:
         if not isinstance(cls.__instance, cls):
             cls.__instance = object.__new__(cls, *args, **kwargs)
         return cls.__instance
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Undefined"
 
 
 Undefined = UndefinedType()
+T = TypeVar("T")
+Optional: TypeAlias = Union[T, UndefinedType]
+"""One of the sepcified types, or the `Undefined` singleton.
+
+
+Examples
+--------
+```py
+MaybeDictOrStr: TypeAlias = Optional[dict[str, Any] | str]
+LongerDictOrStr: TypeAlias = dict[str, Any] | str | UndefinedType
+```
+"""
 
 
 class SchemaBase:
@@ -740,9 +763,9 @@ class SchemaBase:
     the _rootschema class attribute) which is used for validation.
     """
 
-    _schema: Optional[Dict[str, Any]] = None
-    _rootschema: Optional[Dict[str, Any]] = None
-    _class_is_valid_at_instantiation: bool = True
+    _schema: ClassVar[dict[str, Any] | Any] = None
+    _rootschema: ClassVar[dict[str, Any] | None] = None
+    _class_is_valid_at_instantiation: ClassVar[bool] = True
 
     def __init__(self, *args: Any, **kwds: Any) -> None:
         # Two valid options for initialization, which should be handled by
@@ -750,16 +773,17 @@ def __init__(self, *args: Any, **kwds: Any) -> None:
         # - a single arg with no kwds, for, e.g. {'type': 'string'}
         # - zero args with zero or more kwds for {'type': 'object'}
         if self._schema is None:
-            raise ValueError(
-                "Cannot instantiate object of type {}: "
+            msg = (
+                f"Cannot instantiate object of type {self.__class__}: "
                 "_schema class attribute is not defined."
-                "".format(self.__class__)
+                ""
             )
+            raise ValueError(msg)
 
         if kwds:
             assert len(args) == 0
         else:
-            assert len(args) in [0, 1]
+            assert len(args) in {0, 1}
 
         # use object.__setattr__ because we override setattr below.
         object.__setattr__(self, "_args", args)
@@ -769,7 +793,7 @@ def __init__(self, *args: Any, **kwds: Any) -> None:
             self.to_dict(validate=True)
 
     def copy(
-        self, deep: Union[bool, Iterable] = True, ignore: Optional[list] = None
+        self, deep: bool | Iterable[Any] = True, ignore: list[str] | None = None
     ) -> Self:
         """Return a copy of the object
 
@@ -795,7 +819,7 @@ def _shallow_copy(obj):
             else:
                 return obj
 
-        def _deep_copy(obj, ignore: Optional[list] = None):
+        def _deep_copy(obj, ignore: list[str] | None = None):
             if ignore is None:
                 ignore = []
             if isinstance(obj, SchemaBase):
@@ -850,35 +874,35 @@ def __getattr__(self, attr):
             return self._kwds[attr]
         else:
             try:
-                _getattr = super(SchemaBase, self).__getattr__
+                _getattr = super().__getattr__
             except AttributeError:
-                _getattr = super(SchemaBase, self).__getattribute__
+                _getattr = super().__getattribute__
             return _getattr(attr)
 
-    def __setattr__(self, item, val):
+    def __setattr__(self, item, val) -> None:
         self._kwds[item] = val
 
     def __getitem__(self, item):
         return self._kwds[item]
 
-    def __setitem__(self, item, val):
+    def __setitem__(self, item, val) -> None:
         self._kwds[item] = val
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if self._kwds:
-            args = (
-                "{}: {!r}".format(key, val)
+            it = (
+                f"{key}: {val!r}"
                 for key, val in sorted(self._kwds.items())
                 if val is not Undefined
             )
-            args = "\n" + ",\n".join(args)
-            return "{0}({{{1}\n}})".format(
+            args = "\n" + ",\n".join(it)
+            return "{}({{{}\n}})".format(
                 self.__class__.__name__, args.replace("\n", "\n  ")
             )
         else:
-            return "{}({!r})".format(self.__class__.__name__, self._args[0])
+            return f"{self.__class__.__name__}({self._args[0]!r})"
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return (
             type(self) is type(other)
             and self._args == other._args
@@ -889,9 +913,9 @@ def to_dict(
         self,
         validate: bool = True,
         *,
-        ignore: Optional[List[str]] = None,
-        context: Optional[Dict[str, Any]] = None,
-    ) -> dict:
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Return a dictionary representation of the object
 
         Parameters
@@ -939,7 +963,7 @@ def to_dict(
             # when a non-ordinal data type is specifed manually
             # or if the encoding channel does not support sorting
             if "sort" in parsed_shorthand and (
-                "sort" not in kwds or kwds["type"] not in ["ordinal", Undefined]
+                "sort" not in kwds or kwds["type"] not in {"ordinal", Undefined}
             ):
                 parsed_shorthand.pop("sort")
 
@@ -951,7 +975,7 @@ def to_dict(
                 }
             )
             kwds = {
-                k: v for k, v in kwds.items() if k not in list(ignore) + ["shorthand"]
+                k: v for k, v in kwds.items() if k not in {*list(ignore), "shorthand"}
             }
             if "mark" in kwds and isinstance(kwds["mark"], str):
                 kwds["mark"] = {"type": kwds["mark"]}
@@ -960,10 +984,11 @@ def to_dict(
                 context=context,
             )
         else:
-            raise ValueError(
-                "{} instance has both a value and properties : "
-                "cannot serialize to dict".format(self.__class__)
+            msg = (
+                f"{self.__class__} instance has both a value and properties : "
+                "cannot serialize to dict"
             )
+            raise ValueError(msg)
         if validate:
             try:
                 self.validate(result)
@@ -979,11 +1004,11 @@ def to_dict(
     def to_json(
         self,
         validate: bool = True,
-        indent: Optional[Union[int, str]] = 2,
+        indent: int | str | None = 2,
         sort_keys: bool = True,
         *,
-        ignore: Optional[List[str]] = None,
-        context: Optional[Dict[str, Any]] = None,
+        ignore: list[str] | None = None,
+        context: dict[str, Any] | None = None,
         **kwargs,
     ) -> str:
         """Emit the JSON representation for this object as a string.
@@ -1024,19 +1049,17 @@ def to_json(
         return json.dumps(dct, indent=indent, sort_keys=sort_keys, **kwargs)
 
     @classmethod
-    def _default_wrapper_classes(cls) -> Generator[Type["SchemaBase"], None, None]:
+    def _default_wrapper_classes(cls) -> Iterator[type[SchemaBase]]:
         """Return the set of classes used within cls.from_dict()"""
         return _subclasses(SchemaBase)
 
     @classmethod
     def from_dict(
-        cls,
-        dct: dict,
+        cls: type[TSchemaBase],
+        dct: dict[str, Any],
         validate: bool = True,
-        _wrapper_classes: Optional[Iterable[Type["SchemaBase"]]] = None,
-        # Type hints for this method would get rather complicated
-        # if we want to provide a more specific return type
-    ) -> "SchemaBase":
+        _wrapper_classes: Iterable[type[SchemaBase]] | None = None,
+    ) -> TSchemaBase:
         """Construct class from a dictionary representation
 
         Parameters
@@ -1075,7 +1098,7 @@ def from_json(
         **kwargs: Any,
         # Type hints for this method would get rather complicated
         # if we want to provide a more specific return type
-    ) -> Any:
+    ) -> ChartType:
         """Instantiate the object from a valid JSON string
 
         Parameters
@@ -1092,12 +1115,12 @@ def from_json(
         chart : Chart object
             The altair Chart object built from the specification.
         """
-        dct = json.loads(json_string, **kwargs)
-        return cls.from_dict(dct, validate=validate)
+        dct: dict[str, Any] = json.loads(json_string, **kwargs)
+        return cls.from_dict(dct, validate=validate)  # type: ignore[return-value]
 
     @classmethod
     def validate(
-        cls, instance: Dict[str, Any], schema: Optional[Dict[str, Any]] = None
+        cls, instance: dict[str, Any], schema: dict[str, Any] | None = None
     ) -> None:
         """
         Validate the instance against the class schema in the context of the
@@ -1112,7 +1135,7 @@ def validate(
         )
 
     @classmethod
-    def resolve_references(cls, schema: Optional[dict] = None) -> dict:
+    def resolve_references(cls, schema: dict[str, Any] | None = None) -> dict[str, Any]:
         """Resolve references in the context of this object's schema or root schema."""
         schema_to_pass = schema or cls._schema
         # For the benefit of mypy
@@ -1124,7 +1147,7 @@ def resolve_references(cls, schema: Optional[dict] = None) -> dict:
 
     @classmethod
     def validate_property(
-        cls, name: str, value: Any, schema: Optional[dict] = None
+        cls, name: str, value: Any, schema: dict[str, Any] | None = None
     ) -> None:
         """
         Validate a property against property schema in the context of the
@@ -1136,11 +1159,22 @@ def validate_property(
             value, props.get(name, {}), rootschema=cls._rootschema or cls._schema
         )
 
-    def __dir__(self) -> list:
-        return sorted(list(super().__dir__()) + list(self._kwds.keys()))
+    def __dir__(self) -> list[str]:
+        return sorted(chain(super().__dir__(), self._kwds))
+
+
+TSchemaBase = TypeVar("TSchemaBase", bound=SchemaBase)
+
 
+def _is_dict(obj: Any | dict[Any, Any]) -> TypeIs[dict[Any, Any]]:
+    return isinstance(obj, dict)
 
-def _passthrough(*args, **kwds):
+
+def _is_list(obj: Any | list[Any]) -> TypeIs[list[Any]]:
+    return isinstance(obj, list)
+
+
+def _passthrough(*args: Any, **kwds: Any) -> Any | dict[str, Any]:
     return args[0] if args else kwds
 
 
@@ -1149,21 +1183,21 @@ class _FromDict:
 
     The primary purpose of using this class is to be able to build a hash table
     that maps schemas to their wrapper classes. The candidate classes are
-    specified in the ``class_list`` argument to the constructor.
+    specified in the ``wrapper_classes`` positional-only argument to the constructor.
     """
 
     _hash_exclude_keys = ("definitions", "title", "description", "$schema", "id")
 
-    def __init__(self, class_list: Iterable[Type[SchemaBase]]) -> None:
+    def __init__(self, wrapper_classes: Iterable[type[SchemaBase]], /) -> None:
         # Create a mapping of a schema hash to a list of matching classes
         # This lets us quickly determine the correct class to construct
-        self.class_dict = collections.defaultdict(list)
-        for cls in class_list:
-            if cls._schema is not None:
-                self.class_dict[self.hash_schema(cls._schema)].append(cls)
+        self.class_dict: dict[int, list[type[SchemaBase]]] = defaultdict(list)
+        for tp in wrapper_classes:
+            if tp._schema is not None:
+                self.class_dict[self.hash_schema(tp._schema)].append(tp)
 
     @classmethod
-    def hash_schema(cls, schema: dict, use_json: bool = True) -> int:
+    def hash_schema(cls, schema: dict[str, Any], use_json: bool = True) -> int:
         """
         Compute a python hash for a nested dictionary which
         properly handles dicts, lists, sets, and tuples.
@@ -1198,84 +1232,111 @@ def _freeze(val):
 
             return hash(_freeze(schema))
 
+    @overload
     def from_dict(
         self,
-        dct: dict,
-        cls: Optional[Type[SchemaBase]] = None,
-        schema: Optional[dict] = None,
-        rootschema: Optional[dict] = None,
-        default_class=_passthrough,
-        # Type hints for this method would get rather complicated
-        # if we want to provide a more specific return type
-    ) -> Any:
+        dct: TSchemaBase,
+        tp: None = ...,
+        schema: None = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: None = ...,
+        schema: Any = ...,
+        rootschema: None = ...,
+        default_class: type[TSchemaBase] = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: None = ...,
+        schema: dict[str, Any] = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> SchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any],
+        tp: type[TSchemaBase],
+        schema: None = ...,
+        rootschema: None = ...,
+        default_class: Any = ...,
+    ) -> TSchemaBase: ...
+    @overload
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]],
+        tp: type[TSchemaBase],
+        schema: dict[str, Any],
+        rootschema: dict[str, Any] | None = ...,
+        default_class: Any = ...,
+    ) -> Never: ...
+    def from_dict(
+        self,
+        dct: dict[str, Any] | list[dict[str, Any]] | TSchemaBase,
+        tp: type[TSchemaBase] | None = None,
+        schema: dict[str, Any] | None = None,
+        rootschema: dict[str, Any] | None = None,
+        default_class: Any = _passthrough,
+    ) -> TSchemaBase:
         """Construct an object from a dict representation"""
-        if (schema is None) == (cls is None):
-            raise ValueError("Must provide either cls or schema, but not both.")
-        if schema is None:
-            # Can ignore type errors as  cls is not None in case schema is
-            schema = cls._schema  # type: ignore[union-attr]
-            # For the benefit of mypy
-            assert schema is not None
-            if rootschema:
-                rootschema = rootschema
-            elif cls is not None and cls._rootschema is not None:
-                rootschema = cls._rootschema
-            else:
-                rootschema = None
-        rootschema = rootschema or schema
-
+        target_tp: type[TSchemaBase]
+        current_schema: dict[str, Any]
         if isinstance(dct, SchemaBase):
-            return dct
-
-        if cls is None:
+            return dct  # type: ignore[return-value]
+        elif tp is not None:
+            current_schema = tp._schema
+            root_schema = rootschema or tp._rootschema or current_schema
+            target_tp = tp
+        elif schema is not None:
             # If there are multiple matches, we use the first one in the dict.
             # Our class dict is constructed breadth-first from top to bottom,
             # so the first class that matches is the most general match.
-            matches = self.class_dict[self.hash_schema(schema)]
-            if matches:
-                cls = matches[0]
-            else:
-                cls = default_class
-        schema = _resolve_references(schema, rootschema)
-
-        if "anyOf" in schema or "oneOf" in schema:
-            schemas = schema.get("anyOf", []) + schema.get("oneOf", [])
-            for possible_schema in schemas:
+            current_schema = schema
+            root_schema = rootschema or current_schema
+            matches = self.class_dict[self.hash_schema(current_schema)]
+            target_tp = matches[0] if matches else default_class
+        else:
+            msg = "Must provide either `tp` or `schema`, but not both."
+            raise ValueError(msg)
+
+        from_dict = partial(self.from_dict, rootschema=root_schema)
+        # Can also return a list?
+        resolved = _resolve_references(current_schema, root_schema)
+        if "anyOf" in resolved or "oneOf" in resolved:
+            schemas = resolved.get("anyOf", []) + resolved.get("oneOf", [])
+            for possible in schemas:
                 try:
-                    validate_jsonschema(dct, possible_schema, rootschema=rootschema)
+                    validate_jsonschema(dct, possible, rootschema=root_schema)
                 except jsonschema.ValidationError:
                     continue
                 else:
-                    return self.from_dict(
-                        dct,
-                        schema=possible_schema,
-                        rootschema=rootschema,
-                        default_class=cls,
-                    )
+                    return from_dict(dct, schema=possible, default_class=target_tp)
 
-        if isinstance(dct, dict):
+        if _is_dict(dct):
             # TODO: handle schemas for additionalProperties/patternProperties
-            props = schema.get("properties", {})
-            kwds = {}
-            for key, val in dct.items():
-                if key in props:
-                    val = self.from_dict(val, schema=props[key], rootschema=rootschema)
-                kwds[key] = val
-            return cls(**kwds)
-
-        elif isinstance(dct, list):
-            item_schema = schema.get("items", {})
-            dct = [
-                self.from_dict(val, schema=item_schema, rootschema=rootschema)
-                for val in dct
-            ]
-            return cls(dct)
+            props: dict[str, Any] = resolved.get("properties", {})
+            kwds = {
+                k: (from_dict(v, schema=props[k]) if k in props else v)
+                for k, v in dct.items()
+            }
+            return target_tp(**kwds)
+        elif _is_list(dct):
+            item_schema: dict[str, Any] = resolved.get("items", {})
+            return target_tp([from_dict(k, schema=item_schema) for k in dct])
         else:
-            return cls(dct)
+            # NOTE: Unsure what is valid here
+            return target_tp(dct)
 
 
 class _PropertySetter:
-    def __init__(self, prop: str, schema: dict) -> None:
+    def __init__(self, prop: str, schema: dict[str, Any]) -> None:
         self.prop = prop
         self.schema = schema
 
@@ -1315,14 +1376,14 @@ def __get__(self, obj, cls):
             pass
         return self
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any):
         obj = self.obj.copy()
         # TODO: use schema to validate
         obj[self.prop] = args[0] if args else kwargs
         return obj
 
 
-def with_property_setters(cls: TSchemaBase) -> TSchemaBase:
+def with_property_setters(cls: type[TSchemaBase]) -> type[TSchemaBase]:
     """
     Decorator to add property setters to a Schema class.
     """
diff --git a/tools/schemapi/utils.py b/tools/schemapi/utils.py
index 2754f19df..8212f72e8 100644
--- a/tools/schemapi/utils.py
+++ b/tools/schemapi/utils.py
@@ -1,13 +1,19 @@
 """Utilities for working with schemas"""
 
+from __future__ import annotations
+from itertools import chain
 import keyword
 import re
 import subprocess
 import textwrap
 import urllib
-from typing import Any, Dict, Final, Iterable, List, Optional, Union
+from typing import Any, Final, Iterable, TYPE_CHECKING, Iterator, Sequence
+from operator import itemgetter
+from tools.schemapi.schemapi import _resolve_references as resolve_references
 
-from .schemapi import _resolve_references as resolve_references
+if TYPE_CHECKING:
+    from typing_extensions import LiteralString
+    from pathlib import Path
 
 EXCLUDE_KEYS: Final = ("definitions", "title", "description", "$schema", "id")
 
@@ -22,6 +28,133 @@
 }
 
 
+class _TypeAliasTracer:
+    """Recording all `enum` -> `Literal` translations.
+
+    Rewrites as `TypeAlias` to be reused anywhere, and not clog up method definitions.
+
+    Parameters
+    ----------
+    fmt
+        A format specifier to produce the `TypeAlias` name.
+
+        Will be provided a `SchemaInfo.title` as a single positional argument.
+    *ruff_check
+        Optional [ruff rule codes](https://docs.astral.sh/ruff/rules/),
+        each prefixed with `--select ` and follow a `ruff check --fix ` call.
+
+        If not provided, uses `[tool.ruff.lint.select]` from `pyproject.toml`.
+    ruff_format
+        Optional argument list supplied to [ruff format](https://docs.astral.sh/ruff/formatter/#ruff-format)
+
+    Attributes
+    ----------
+    _literals: dict[str, str]
+        `{alias_name: literal_statement}`
+    _literals_invert: dict[str, str]
+        `{literal_statement: alias_name}`
+    aliases: list[tuple[str, str]]
+        `_literals` sorted by `alias_name`
+    _imports: Sequence[str]
+        Prefined import statements to appear at beginning of module.
+    """
+
+    def __init__(
+        self,
+        fmt: str = "{}_T",
+        *ruff_check: str,
+        ruff_format: Sequence[str] | None = None,
+    ) -> None:
+        self.fmt: str = fmt
+        self._literals: dict[str, str] = {}
+        self._literals_invert: dict[str, str] = {}
+        self.aliases: list[tuple[str, str]] = []
+        self._imports: Sequence[str] = (
+            "from __future__ import annotations\n",
+            "from typing import Literal",
+            "from typing_extensions import TypeAlias",
+        )
+        self._cmd_check: list[str] = ["--fix"]
+        self._cmd_format: Sequence[str] = ruff_format or ()
+        for c in ruff_check:
+            self._cmd_check.extend(("--select", c))
+
+    def _update_literals(self, name: str, tp: str, /) -> None:
+        """Produces an inverted index, to reuse a `Literal` when `SchemaInfo.title` is empty."""
+        self._literals[name] = tp
+        self._literals_invert[tp] = name
+
+    def add_literal(
+        self, info: SchemaInfo, tp: str, /, *, replace: bool = False
+    ) -> str:
+        """`replace=True` returns the eventual alias name.
+
+        - Doing so will mean that the `_typing` module must be written first, before the source of `info`.
+        - Otherwise, `ruff` will raise an error during `check`/`format`, as the import will be invalid.
+        - Where a `title` is not found, an attempt will be made to find an existing alias definition that had one.
+        """
+        if info.title:
+            alias = self.fmt.format(info.title)
+            if alias not in self._literals:
+                self._update_literals(alias, tp)
+            if replace:
+                tp = alias
+        elif (alias := self._literals_invert.get(tp)) and replace:
+            tp = alias
+        return tp
+
+    def generate_aliases(self) -> Iterator[str]:
+        """Represents a line per `TypeAlias` declaration.
+
+        Additionally, stores in `self.aliases` an alphabetically sorted list of tuples.
+        """
+        self.aliases = sorted(self._literals.items(), key=itemgetter(0))
+        for name, statement in self.aliases:
+            yield f"{name}: TypeAlias = {statement}"
+
+    def write_module(
+        self, fp: Path, *extra_imports: str, header: LiteralString
+    ) -> None:
+        """Write all collected `TypeAlias`'s to `fp`.
+
+        Parameters
+        ----------
+        fp
+            Path to new module.
+        *extra_imports
+            Follows `self._imports` block.
+        header
+            `tools.generate_schema_wrapper.HEADER`.
+        """
+        ruff_format = ["ruff", "format", fp]
+        if self._cmd_format:
+            ruff_format.extend(self._cmd_format)
+        commands = (["ruff", "check", fp, *self._cmd_check], ruff_format)
+        imports = (header, "\n", *self._imports, *extra_imports, "\n\n")
+        it = chain(imports, self.generate_aliases())
+        fp.write_text("\n".join(it), encoding="utf-8")
+        for cmd in commands:
+            r = subprocess.run(cmd, check=True)
+            r.check_returncode()
+
+    @property
+    def n_entries(self) -> int:
+        """Number of unique `TypeAlias` defintions collected."""
+        return len(self._literals)
+
+
+TypeAliasTracer = _TypeAliasTracer("{}_T", "I001", "I002")
+"""An instance of `_TypeAliasTracer`.
+
+Collects a cache of unique `Literal` types used globally.
+
+These are then converted to `TypeAlias` statements, written to another module.
+
+Allows for a single definition to be reused multiple times,
+rather than repeating long literals in every method definition.
+"""
+
+
 def get_valid_identifier(
     prop: str,
     replacement_character: str = "",
@@ -104,9 +237,9 @@ class SchemaProperties:
 
     def __init__(
         self,
-        properties: Dict[str, Any],
+        properties: dict[str, Any],
         schema: dict,
-        rootschema: Optional[dict] = None,
+        rootschema: dict | None = None,
     ) -> None:
         self._properties = properties
         self._schema = schema
@@ -115,14 +248,14 @@ def __init__(
     def __bool__(self) -> bool:
         return bool(self._properties)
 
-    def __dir__(self) -> List[str]:
+    def __dir__(self) -> list[str]:
         return list(self._properties.keys())
 
     def __getattr__(self, attr):
         try:
             return self[attr]
         except KeyError:
-            return super(SchemaProperties, self).__getattr__(attr)
+            return super().__getattr__(attr)
 
     def __getitem__(self, attr):
         dct = self._properties[attr]
@@ -147,7 +280,7 @@ class SchemaInfo:
     """A wrapper for inspecting a JSON schema"""
 
     def __init__(
-        self, schema: Dict[str, Any], rootschema: Optional[Dict[str, Any]] = None
+        self, schema: dict[str, Any], rootschema: dict[str, Any] | None = None
     ) -> None:
         if not rootschema:
             rootschema = schema
@@ -155,7 +288,7 @@ def __init__(
         self.rootschema = rootschema
         self.schema = resolve_references(schema, rootschema)
 
-    def child(self, schema: dict) -> "SchemaInfo":
+    def child(self, schema: dict) -> SchemaInfo:
         return self.__class__(schema, rootschema=self.rootschema)
 
     def __repr__(self) -> str:
@@ -169,7 +302,7 @@ def __repr__(self) -> str:
                 rval = "{...}"
             elif key == "properties":
                 rval = "{\n    " + "\n    ".join(sorted(map(repr, val))) + "\n  }"
-            keys.append('"{}": {}'.format(key, rval))
+            keys.append(f'"{key}": {rval}')
         return "SchemaInfo({\n  " + "\n  ".join(keys) + "\n})"
 
     @property
@@ -182,13 +315,20 @@ def title(self) -> str:
     def get_python_type_representation(
         self,
         for_type_hints: bool = False,
-        altair_classes_prefix: Optional[str] = None,
+        altair_classes_prefix: str | None = None,
         return_as_str: bool = True,
-        additional_type_hints: Optional[List[str]] = None,
-    ) -> Union[str, List[str]]:
+        additional_type_hints: list[str] | None = None,
+    ) -> str | list[str]:
         # This is a list of all types which can be used for the current SchemaInfo.
         # This includes Altair classes, standard Python types, etc.
-        type_representations: List[str] = []
+        type_representations: list[str] = []
+        TP_CHECK_ONLY = {"Parameter", "SchemaBase"}
+        """Most common annotations are include in `TYPE_CHECKING` block.
+        They do not require `core.` prefix, and this saves many lines of code.
+
+        Eventually a more robust solution would apply to more types from `core`.
+        """
+
         if self.title:
             if for_type_hints:
                 # To keep type hints simple, we only use the SchemaBase class
@@ -204,9 +344,9 @@ def get_python_type_representation(
                     # try to check for the type of the Parameter.param attribute
                     # but then we would need to write some overload signatures for
                     # api.param).
-                    class_names.append("_Parameter")
+                    class_names.append("Parameter")
                 if self.title == "ParameterExtent":
-                    class_names.append("_Parameter")
+                    class_names.append("Parameter")
 
                 prefix = (
                     "" if not altair_classes_prefix else altair_classes_prefix + "."
@@ -217,7 +357,10 @@ def get_python_type_representation(
                 if not prefix:
                     class_names = [f'"{n}"' for n in class_names]
                 else:
-                    class_names = [f"{prefix}{n}" for n in class_names]
+                    class_names = (
+                        n if n in TP_CHECK_ONLY else f"{prefix}{n}" for n in class_names
+                    )
+                    # class_names = [f"{prefix}{n}" for n in class_names]
                 type_representations.extend(class_names)
             else:
                 # use RST syntax for generated sphinx docs
@@ -226,9 +369,11 @@ def get_python_type_representation(
         if self.is_empty():
             type_representations.append("Any")
         elif self.is_enum():
-            type_representations.append(
-                "Literal[{}]".format(", ".join(map(repr, self.enum)))
-            )
+            s = ", ".join(f"{s!r}" for s in self.enum)
+            tp_str = f"Literal[{s}]"
+            if for_type_hints:
+                tp_str = TypeAliasTracer.add_literal(self, tp_str, replace=True)
+            type_representations.append(tp_str)
         elif self.is_anyOf():
             type_representations.extend(
                 [
@@ -283,7 +428,8 @@ def get_python_type_representation(
         elif self.type in jsonschema_to_python_types:
             type_representations.append(jsonschema_to_python_types[self.type])
         else:
-            raise ValueError("No Python type representation available for this schema")
+            msg = "No Python type representation available for this schema"
+            raise ValueError(msg)
 
         # Shorter types are usually the more relevant ones, e.g. `str` instead
         # of `SchemaBase`. Output order from set is non-deterministic -> If
@@ -309,7 +455,14 @@ def get_python_type_representation(
             # If it's not for_type_hints but instead for the docstrings, we don't want
             # to include Union as it just clutters the docstrings.
             if len(type_representations) > 1 and for_type_hints:
-                type_representations_str = f"Union[{type_representations_str}]"
+                # Use parameterised `TypeAlias` instead of exposing `UndefinedType`
+                # `Union` is collapsed by `ruff` later
+                if type_representations_str.endswith(", UndefinedType"):
+                    s = type_representations_str.replace(", UndefinedType", "")
+                    s = f"Optional[Union[{s}]]"
+                else:
+                    s = f"Union[{type_representations_str}]"
+                return s
             return type_representations_str
         else:
             return type_representations
@@ -339,23 +492,23 @@ def additionalProperties(self) -> bool:
         return self.schema.get("additionalProperties", True)
 
     @property
-    def type(self) -> Optional[str]:
+    def type(self) -> str | list[Any] | None:
         return self.schema.get("type", None)
 
     @property
-    def anyOf(self) -> List["SchemaInfo"]:
+    def anyOf(self) -> list[SchemaInfo]:
         return [self.child(s) for s in self.schema.get("anyOf", [])]
 
     @property
-    def oneOf(self) -> List["SchemaInfo"]:
+    def oneOf(self) -> list[SchemaInfo]:
         return [self.child(s) for s in self.schema.get("oneOf", [])]
 
     @property
-    def allOf(self) -> List["SchemaInfo"]:
+    def allOf(self) -> list[SchemaInfo]:
         return [self.child(s) for s in self.schema.get("allOf", [])]
 
     @property
-    def not_(self) -> "SchemaInfo":
+    def not_(self) -> SchemaInfo:
         return self.child(self.schema.get("not", {}))
 
     @property
@@ -371,7 +524,7 @@ def refname(self) -> str:
         return self.raw_schema.get("$ref", "#/").split("/")[-1]
 
     @property
-    def ref(self) -> Optional[str]:
+    def ref(self) -> str | None:
         return self.raw_schema.get("$ref", None)
 
     @property
@@ -435,7 +588,8 @@ def is_object(self) -> bool:
         ):
             return True
         else:
-            raise ValueError("Unclear whether schema.is_object() is True")
+            msg = "Unclear whether schema.is_object() is True"
+            raise ValueError(msg)
 
     def is_value(self) -> bool:
         return not self.is_object()
@@ -445,7 +599,7 @@ def is_array(self) -> bool:
 
 
 def indent_docstring(
-    lines: List[str], indent_level: int, width: int = 100, lstrip=True
+    lines: list[str], indent_level: int, width: int = 100, lstrip=True
 ) -> str:
     """Indent a docstring for use in generated code"""
     final_lines = []
@@ -546,13 +700,12 @@ def flatten(container: Iterable) -> Iterable:
     """
     for i in container:
         if isinstance(i, (list, tuple)):
-            for j in flatten(i):
-                yield j
+            yield from flatten(i)
         else:
             yield i
 
 
-def ruff_format_str(code: Union[str, List[str]]) -> str:
+def ruff_format_str(code: str | list[str]) -> str:
     if isinstance(code, list):
         code = "\n".join(code)
 
@@ -564,3 +717,45 @@ def ruff_format_str(code: Union[str, List[str]]) -> str:
         capture_output=True,
     )
     return r.stdout.decode()
+
+
+def ruff_format_py(fp: Path, /, *extra_args: str) -> None:
+    """Format an existing file.
+
+    Running on `win32` after writing lines will ensure "lf" is used before:
+    ```bash
+    ruff format --diff --check .
+    ```
+    """
+
+    cmd = ["ruff", "format", fp]
+    if extra_args:
+        cmd.extend(extra_args)
+    r = subprocess.run(cmd, check=True)
+    r.check_returncode()
+
+
+def ruff_write_lint_format_str(
+    fp: Path, code: str | Iterable[str], /, *, encoding: str = "utf-8"
+) -> None:
+    """Combined steps of writing, `ruff check`, `ruff format`.
+
+    Notes
+    -----
+    - `fp` is written to first, as the size before formatting will be the smallest
+        - Better utilizes `ruff` performance, rather than `python` str and io
+    - `code` is no longer bound to `list`
+    - Encoding set as default
+    - `I001/2` are `isort` rules, to sort imports.
+    """
+    commands = (
+        ["ruff", "check", fp, "--fix"],
+        ["ruff", "check", fp, "--fix", "--select", "I001", "--select", "I002"],
+    )
+    if not isinstance(code, str):
+        code = "\n".join(code)
+    fp.write_text(code, encoding=encoding)
+    for cmd in commands:
+        r = subprocess.run(cmd, check=True)
+        r.check_returncode()
+    ruff_format_py(fp)
diff --git a/tools/update_init_file.py b/tools/update_init_file.py
index e4fa65a86..fc694b7d8 100644
--- a/tools/update_init_file.py
+++ b/tools/update_init_file.py
@@ -3,42 +3,42 @@
 based on the updated Altair schema.
 """
 
-import inspect
-import sys
-from os.path import abspath, dirname, join
+from __future__ import annotations
+
+from inspect import ismodule, getattr_static
 from pathlib import Path
 from typing import (
     IO,
     Any,
     Iterable,
     List,
-    Optional,
-    Protocol,
     Sequence,
-    Type,
     TypeVar,
     Union,
     cast,
+    TYPE_CHECKING,
+    Literal,
 )
+import typing as t
+import typing_extensions as te
 
-if sys.version_info >= (3, 13):
-    from typing import TypeIs
-else:
-    from typing_extensions import TypeIs
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-from typing import Final, Literal
-
-ROOT_DIR: Final = abspath(join(dirname(__file__), ".."))
-sys.path.insert(0, abspath(dirname(__file__)))
-from schemapi.utils import ruff_format_str  # noqa: E402
+from tools.schemapi.utils import ruff_write_lint_format_str
 
-# Import Altair from head
-sys.path.insert(0, ROOT_DIR)
-import altair as alt  # noqa: E402
+_TYPING_CONSTRUCTS = {
+    te.TypeAlias,
+    TypeVar,
+    cast,
+    List,
+    Any,
+    Literal,
+    Union,
+    Iterable,
+    t.Protocol,
+    te.Protocol,
+    Sequence,
+    IO,
+    annotations,
+}
 
 
 def update__all__variable() -> None:
@@ -47,8 +47,11 @@ def update__all__variable() -> None:
     Jupyter.
     """
     # Read existing file content
-    init_path = alt.__file__
-    with open(init_path, "r") as f:
+    import altair as alt
+
+    encoding = "utf-8"
+    init_path = Path(alt.__file__)
+    with init_path.open(encoding=encoding) as f:
         lines = f.readlines()
     lines = [line.strip("\n") for line in lines]
 
@@ -61,62 +64,62 @@ def update__all__variable() -> None:
         elif first_definition_line is not None and line.startswith("]"):
             last_definition_line = idx
             break
-    assert first_definition_line is not None and last_definition_line is not None
-
-    # Figure out which attributes are relevant
-    relevant_attributes = [x for x in alt.__dict__ if _is_relevant_attribute(x)]
-    relevant_attributes.sort()
-    relevant_attributes_str = f"__all__ = {relevant_attributes}"
+    assert first_definition_line is not None
+    assert last_definition_line is not None
 
     # Put file back together, replacing old definition of __all__ with new one, keeping
     # the rest of the file as is
-    new_lines = (
-        lines[:first_definition_line]
-        + [relevant_attributes_str]
-        + lines[last_definition_line + 1 :]
+    new_lines = [
+        *lines[:first_definition_line],
+        f"__all__ = {relevant_attributes(alt.__dict__)}",
+        *lines[last_definition_line + 1 :],
+    ]
+    # Write new version of altair/__init__.py
+    # Format file content with ruff
+    ruff_write_lint_format_str(init_path, new_lines)
+
+
+def relevant_attributes(namespace: dict[str, Any], /) -> list[str]:
+    """Figure out which attributes in `__all__` are relevant.
+
+    Returns an alphabetically sorted list, to insert into `__all__`.
+
+    Parameters
+    ----------
+    namespace
+        A module dict, like `altair.__dict__`
+    """
+    it = (
+        name
+        for name, attr in namespace.items()
+        if (not name.startswith("_")) and _is_relevant(attr)
     )
-    # Format file content with black
-    new_file_content = ruff_format_str("\n".join(new_lines))
+    return sorted(it)
 
-    # Write new version of altair/__init__.py
-    with open(init_path, "w") as f:
-        f.write(new_file_content)
+
+def _is_hashable(obj: Any) -> bool:
+    """Guard to prevent an `in` check occuring on mutable objects."""
+    try:
+        return bool(hash(obj))
+    except TypeError:
+        return False
 
 
-def _is_relevant_attribute(attr_name: str) -> bool:
-    attr = getattr(alt, attr_name)
+def _is_relevant(attr: Any, /) -> bool:
+    """Predicate logic for filtering attributes."""
     if (
-        getattr(attr, "_deprecated", False) is True
-        or attr_name.startswith("_")
-        or attr is TypeVar
-        or attr is Self
-        or attr is Type
-        or attr is cast
-        or attr is List
-        or attr is Any
-        or attr is Literal
-        or attr is Optional
-        or attr is Iterable
-        or attr is Union
-        or attr is Protocol
-        or attr is Sequence
-        or attr is IO
-        or attr is TypeIs
-        or attr_name == "TypingDict"
-        or attr_name == "TypingGenerator"
-        or attr_name == "ValueOrDatum"
+        getattr_static(attr, "_deprecated", False)
+        or attr is TYPE_CHECKING
+        or (_is_hashable(attr) and attr in _TYPING_CONSTRUCTS)
     ):
         return False
+    elif ismodule(attr):
+        # Only include modules which are part of Altair. This excludes built-in
+        # modules (they do not have a __file__ attribute), standard library,
+        # and third-party packages.
+        return getattr_static(attr, "__file__", "").startswith(str(Path.cwd()))
     else:
-        if inspect.ismodule(attr):
-            # Only include modules which are part of Altair. This excludes built-in
-            # modules (they do not have a __file__ attribute), standard library,
-            # and third-party packages.
-            return getattr(attr, "__file__", "").startswith(
-                str(Path(alt.__file__).parent)
-            )
-        else:
-            return True
+        return True
 
 
 if __name__ == "__main__":